Ejecutando Tu Propio Nodo Mostro

Mostro v0.20.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:

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 la comisión que tú fijes (la plantilla trae 0; 0.6% es una opción común). Con 0.6%, una comunidad que hace $10,000 en operaciones mensuales gana ~$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)

1. Alice quiere VENDER Bitcoin por $50 USD → Crea una orden en Mostro
2. Bob quiere COMPRAR Bitcoin con $50 USD → Ve la orden de Alice y la toma
3. Mostro crea una "caja fuerte" (hold invoice) → Alice envía sus Bitcoin a la caja fuerte
4. Bob envía $50 a Alice por transferencia bancaria, Zelle, efectivo, etc. → Bob presiona "Fiat Enviado" en su app
5. Alice confirma que recibió los $50 → Presiona "Liberar"
6. Mostro libera los Bitcoin de la caja fuerte a Bob → ¡Operación completada! ✓

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:

RecursoMínimoRecomendado
CPU2 vCPUs (compartidos)2+ vCPUs
RAM2 GB4 GB
Almacenamiento60 GB SSD100 GB SSD
Ancho de banda3 TB/mes3+ TB/mes
SOUbuntu 22.04+ LTSUbuntu 24.04 LTS

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

Estas cifras son solo para Mostro. Si LND corre en el mismo VPS, suma al menos 2 GB de RAM y el disco que necesita su backend de Bitcoin (ver 2.2).

Proveedores populares de VPS:

💡 Consejo

Muchos proveedores de VPS aceptan pagos en Bitcoin. Busca esa opción si quieres mantener coherencia con la filosofía de 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:

OpciónDificultadCostoNotas
Usar un nodo LND existenteFácilGratis (si tienes uno)Mejor si alguien ya tiene uno
Ejecutar LND en el mismo VPSDifícilVPS más grande + liquidez4GB+ de RAM y disco para el backend de Bitcoin (ver abajo)
Solución nodo-en-cajaMedio$200-600 + liquidezStart9, Umbrel, RaspiBlitz
StartOS con paquete MostroMás fácil$300-600 + liquidezStart9 tiene un paquete Mostro de un clic
Usar Voltage.cloudFácilDesde ~$20/mes + liquidezVoltage — LND alojado con infraestructura administrada
⚠️ Importante

Mostro requiere específicamente LND (no CLN/Core Lightning, no Eclair, no LDK). Asegúrate de que tu nodo Lightning ejecute LND.

Lo que necesitas de tu nodo LND:

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, listar canales para el reporte de salud, 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.

Si no puedes escribir en el directorio de datos de LND (un contenedor, un nodo-en-caja, un nodo alojado), omite --save_to: lncli imprimirá entonces el macaroon en hex, y tú lo conviertes en archivo en el lugar donde corre Mostro. lncli también puede crearlo desde otra máquina, apuntando al nodo con sus credenciales de admin:

lncli --rpcserver=NODE_ADDRESS:10009 --tlscertpath=tls.cert --macaroonpath=admin.macaroon \
  bakemacaroon --root_key_id 7 info:read invoices:read invoices:write offchain:read offchain:write
# copia el hex que imprime, luego:
echo "PASTE_THE_HEX_HERE" | xxd -r -p > mostro.macaroon   # apt install -y xxd si falta

A diferencia de Mostro, lncli comprueba que NODE_ADDRESS figure en el certificado del nodo. LND incluye las direcciones de la propia máquina al crearlo, pero no, por ejemplo, una dirección de VPN agregada después. Si la conexión falla con un error de certificado, ejecuta lncli en el propio nodo, o agrega la dirección con tlsextraip (o tlsextradomain) en lnd.conf, borra tls.cert y tls.key y reinicia LND para que cree un certificado nuevo; luego copia también el nuevo tls.cert a Mostro.

Cómo se conecta Mostro a LND

Mostro habla con el puerto gRPC de LND (10009 por defecto) y se autentica con tls.cert y el macaroon. Hay tres cosas que conviene saber antes de elegir dónde corre LND:

LND en el mismo VPS

Instala LND siguiendo la guía oficial (docs.lightning.engineering), usando sus binarios de release. LND necesita una vista de la cadena de Bitcoin, y esa elección decide el tamaño de tu VPS:

BackendDiscoCompromiso
bitcoind, nodo completoMás de 700 GBEl más robusto. La sincronización inicial toma días.
bitcoind, podadoDecenas de GBSoportado por LND y robusto; la sincronización inicial sigue tomando días.
neutrinoUnos pocos GBSin nodo de Bitcoin y con un arranque rápido, pero depende de los pares desde los que se sincroniza. Un nodo neutrino que se estancó unas 21 horas es la razón por la que Mostro ahora vigila la sincronización de LND (5.4). Si lo usas, apúntalo a nodos de Bitcoin de tu confianza con neutrino.connect y configura las alertas de salud.

Luego haz que LND sea alcanzable desde Mostro. Con la instalación nativa (Opción C) nada cambia: usa https://127.0.0.1:10009. Con Docker (Opciones A y B) el contenedor es un host aparte, así que elige una:

LND en otro servidor o en casa

Conecta las dos máquinas con una VPN como WireGuard o Tailscale, haz que LND escuche en su dirección de la VPN (rpclisten=VPN_IP:10009, y también rpclisten=localhost:10009 para que lncli siga funcionando en el nodo: cualquier línea rpclisten reemplaza la predeterminada) y configura lnd_grpc_host = 'https://VPN_IP:10009'. Copia tls.cert y el macaroon al servidor de Mostro. Abrir el puerto 10009 a internet también funciona, pero entonces el macaroon es lo único que hay entre el mundo y tu nodo: evítalo. Un nodo en casa debe estar en línea 24/7: un corte de luz o una conexión caída deja esperando las operaciones de tus usuarios.

Nodo-en-caja (Start9, Umbrel, RaspiBlitz)

Estos sistemas instalan y actualizan LND por ti, normalmente en una computadora pequeña en casa. En StartOS el camino más simple es el propio paquete de Mostro, que se conecta al servicio LND de la misma caja. Usar el LND de la caja desde un Mostro en un VPS es más difícil: estos sistemas gestionan ellos mismos la configuración de LND, así que quizá no puedas agregar una línea rpclisten, y a menudo exponen gRPC solo en la red local o por Tor, que Mostro no puede usar. Revisa qué permite tu sistema antes de planificarlo así. Cada sistema muestra los datos de conexión de LND en su propia interfaz (en StartOS, en las propiedades del servicio LND); lncli suele correr dentro del contenedor de LND; en Umbrel, por ejemplo, sudo docker exec -it lightning_lnd_1 lncli ... (verifica el nombre con sudo docker ps). Crea el macaroon en hex como se muestra arriba.

Voltage (LND alojado)

Voltage ejecuta LND por ti. Descarga tls.cert y el macaroon de admin desde el panel del nodo, úsalos solo para crear el macaroon restringido de Mostro desde tu propia máquina (ver arriba) y apunta lnd_grpc_host a la dirección gRPC que muestra el panel, puerto 10009. Tú sigues aportando y administrando la liquidez.

Ajustes de LND que afectan a Mostro

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?

Volumen de trading objetivoLiquidez sugeridaBTC aproximado
Comunidad pequeña (pocas operaciones/día)1–5 millones de sats0.01–0.05 BTC
Comunidad mediana5–20 millones de sats0.05–0.20 BTC
Comunidad activa20–100 millones de sats0.20–1.0 BTC
💡 Nota sobre Liquidez Lightning

El Bitcoin en tus canales Lightning está bloqueado onchain pero sigue siendo altamente gastable vía Lightning Network. Muchos servicios aceptan pagos Lightning — desde cafeterías hasta proveedores VPS — haciendo tu liquidez bastante flexible para uso cotidiano.

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:

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

⚠️ Importante

Nunca reutilices claves Nostr entre instancias de Mostro. Cada nodo necesita su propia identidad única.

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

TareaDificultadConocimientos necesarios
Alquilar un VPSFácilTarjeta de crédito, navegación web básica
Conectarse por SSHFácilSeguir instrucciones, escribir comandos
Instalar DockerMedioCopiar y pegar comandos, solución básica de problemas
Ejecutar Mostro (Docker)MedioEditar archivos de configuración, entender rutas
Ejecutar Mostro (nativo)DifícilAdministración Linux, compilación de software, systemd
Configurar LND desde ceroDifícilConocimiento significativo de Linux y redes
Gestionar liquidez LightningDifícilEntender la economía de canales Lightning

💡 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:

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

💡 Nota

Docker es necesario para las opciones A y B. Si vas a compilar manualmente (Opción C), puedes saltar este paso.

# 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.20.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:

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

⚠️ Importante

Evita chmod 777. Usa permisos mínimos.

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 (LND debe aceptar la conexión del contenedor, o usa la red del host: ver 2.2):

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

Si LND está en un servidor diferente:

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

Paso 11: Revisar los logs

docker logs -f mostro

Busca estos mensajes:

💡 Nota

No existe un mensaje de "conectado a LND" ni de "conectado al relay". Mostro contacta a LND durante el arranque, así que un daemon que pasa el arranque ya llegó a LND. El fallo, en cambio, es ruidoso: registra Ln node error y termina. Después del arranque consulta a LND cada 15 segundos y registra LND did not answer GetInfo si deja de responder; los pagos salientes esperan entonces hasta que vuelva (5.4). Para los relays, tu señal es la línea del evento de salud: No relay accepted the health event significa que ninguno lo aceptó.

💡 Solución de problemas

Si ves Permission denied (os error 13), vuelve a ajustar permisos: chown -R 1000:1000 ~/mostro-config y reinicia: docker restart mostro.

🎉 ¡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.20.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.

🔒 Nota de Seguridad

Usa siempre un tag de versión específica (ej. mostrop2p/mostro:v0.20.2) en lugar de :latest para controlar despliegues.

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, con una diferencia: make docker-build copia tu macaroon a config/lnd/admin.macaroon, sea cual sea su nombre original, así que apunta Mostro ahí:

lnd_macaroon_file = '/config/lnd/admin.macaroon'  # sigue siendo tu mostro.macaroon restringido, con otro nombre
⚠️ Si LND corre en la misma VPS

A diferencia de la Opción A, el docker/compose.yml del repositorio no mapea host.docker.internal, así que en Linux ese nombre no resuelve dentro del contenedor. Agrega el mapeo al servicio mostro antes de construir:

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

O apunta lnd_grpc_host a la IP local del host. Ten en cuenta que make docker-build también construye la imagen StartOS, que una VPS no necesita: solo cuesta tiempo de compilación.

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
⚠️ Importante

NO instales Rust via apt install rustc. Siempre usa rustup. El paquete del sistema suele estar desactualizado.

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
💡 Consejo

Si la compilación falla por falta de RAM, agrega espacio swap:

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
💡 El asistente interactivo de configuración

Si ejecutas mostrod sin un settings.toml en el directorio indicado y estás en una terminal, te ofrece un menú de configuración que puede armarte el archivo y escribir el nsec en un .env. Sin terminal (Docker, systemd, CI) copia la plantilla, imprime dónde la dejó y termina para que la edites.

Crear el servicio systemd:

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

[Service]
Type=simple
User=mostro
WorkingDirectory=/home/mostro
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?

💡 Consejo

También puedes correr tu propio relay Nostr junto a Mostro. La vía Docker Build (Opción B) incluye uno en su compose.yml; la Opción A y la compilación nativa no.

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.

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.

📝 Nota

Establecer dev_fee_percentage por debajo de 0.10 impedirá que Mostro arranque. Este mínimo asegura financiamiento sostenible del desarrollo.

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

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 sin tomar queda en el libro
max_expiration_days = 15     # La expiración más larga que un creador puede pedir
expiration_seconds = 900     # Cuánto puede esperar una orden tomada la hold invoice
                             # o la factura del comprador antes de volver al libro (15 min)

[lightning]
hold_invoice_expiration_window = 300  # Tiempo que tiene el tomador para pagar la factura o agregar una de cobro (5 min)
hold_invoice_cltv_delta = 144         # Vida del escrow, en bloques (~1 día)

Nota que hold_invoice_expiration_window pertenece a [lightning]: escrito bajo [mostro] se ignora en silencio. Debe ser mayor que 0, y también es la expiración de la factura de la fianza de un tomador.

Una vez bloqueados los sats del vendedor, el comprador tiene aproximadamente hold_invoice_cltv_delta - escrow_deadline_margin_blocks bloques para enviar el pago: 144 − 24 = 120 bloques, unas 20 horas, con los valores por defecto. Cuando eso se agota, Mostro cancela la operación si el comprador nunca marcó el pago como enviado, o abre una disputa si lo hizo (mira 4.9). Los usuarios ven la cuenta regresiva en la app.

4.6 Anti-Spam

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

Un filtro más fino es pow_first_contact. 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

Los clientes deben minar al menos esa dificultad. Quienes usan mostro-cli tienen que poner POW (o -p) en tu valor; si no, sus órdenes nuevas y tomas se descartan sin respuesta.

Un disuasivo más fuerte contra quienes toman órdenes y desaparecen es la fianza anti-abuso (mira 4.11).

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.

⚠️ Seguridad

Mantén listen_address en "127.0.0.1" y nunca expongas el puerto a internet. Configura auth_token siempre que el puerto sea alcanzable por algo distinto de la máquina local, como un túnel SSH o un contenedor sidecar: una conexión reenviada llega como loopback, así que la dirección de escucha por sí sola no es autorización. Con un token configurado, cada llamada que modifica estado debe llevar el header authorization: Bearer <token>.

Además del modo mantenimiento, el RPC incluye las llamadas de reputación RevokeReputationImports y RebindReputationExport (mira 4.13). Ambas se aceptan solo desde loopback, y mostro-cli todavía no tiene comandos para ellas: usa grpcurl. mostro-cli envía MOSTRO_RPC_TOKEN solo a una dirección loopback o por https://, nunca en texto claro a un host remoto.

4.8 Protocolo de Transporte

Desde v0.19.0 un nodo Mostro habla solo el protocolo v2: eventos kind 14 firmados con contenido cifrado NIP-44. El protocolo v1 (gift wraps NIP-59, kind 1059) se eliminó y ya no hay nada que elegir. Deja fuera la línea transport de settings.toml; la plantilla ya no la trae.

Línea en settings.tomlResultado
ningunaProtocolo v2. Recomendado.
transport = "nip44"Protocolo v2. Se acepta y es inofensiva.
transport = "gift-wrap"Mostro se niega a arrancar, con un error que te dice que borres la línea.

Tu nodo anuncia protocol_version 2 en su evento de info kind 38385. Todos los clientes actuales hablan v2: la Mostro App, Mostrix 0.3.1 o posterior, mostro-cli 0.16.2 o posterior y Bosstro. Un cliente que solo habla v1, como una versión vieja de Mostro Mobile, no recibe respuesta de tu nodo: pide a tus usuarios que actualicen.

⚠️ Si actualizas desde v0.18.x

Si tu settings.toml todavía dice transport = "gift-wrap", borra esa línea antes de actualizar. La única forma de seguir atendiendo clientes de protocolo v1 es quedarte en mostrod 0.18.x, que ya no recibe correcciones.

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 normalmente 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
AjusteQué protege
max_final_cltv_expiry_deltaRechaza una factura de cobro cuyo CLTV final permitiría al beneficiario retener tus sats demasiado tiempo. 144 bloques (alrededor de un día) es el máximo que piden las wallets reales. Nunca lo pongas en 0: eso rechaza todas las facturas.
escrow_deadline_margin_blocksMargen de seguridad antes de que LND cancele automáticamente un hold invoice aceptado. Cuando la cadena se acerca a este punto, Mostro cancela la operación o abre una disputa mientras el escrow todavía existe. Desde v0.20.0 Mostro se niega a arrancar a menos que sea al menos 18 (el invoices.holdexpirydelta por defecto de LND, 12, más 6 bloques de holgura) y esté por debajo de hold_invoice_cltv_delta. Si subiste holdexpirydelta, mantén tú este margen al menos 6 bloques por encima. El valor se publica en tu evento de info.
max_inflight_payoutsTope de pagos sin resolver en todo el nodo, para que un beneficiario que nunca liquida no agote tus slots de HTLC. Un pago frenado se retrasa, nunca se descarta.
max_inflight_payouts_per_destinationEl mismo tope por pubkey de destino, y el más eficaz de los dos.
payment_cltv_limitTope del timelock total de una ruta de pago. No debe superar el --max-cltv-expiry de tu LND y debe estar al menos 576 bloques por encima de max_final_cltv_expiry_delta, o los pagos legítimos fallan con "no route".
allow_node_changeGuardia de arranque ante un cambio de nodo Lightning. Déjalo en false y mira 5.8.

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.

💡 Si las APIs de precio están bloqueadas en tu país

Puedes tomar las tasas desde Nostr en lugar de HTTP, publicadas por nodos Mostro en los que confíes. Reutiliza los relays que ya tienes en [nostr], así que funciona en cualquier lugar donde tu nodo ya alcance un relay. Con varios nodos de confianza gana el evento válido más reciente.

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

Mantén publish_to_nostr = true. Además de alimentar a otros nodos, las tasas publicadas le dicen a la Mostro App qué monedas puede cotizar tu nodo a precio de mercado: un código que falte en ellas se ofrece solo a precio fijo. Para cotizar stablecoins y bitcoin en otras redes, mira 4.12.

⚠️ Agregar cualquier bloque [price] cambia el motor de precios

En cuanto settings.toml tiene una tabla [price] o [price.providers.*], Mostro usa el motor multifuente e ignora bitcoin_price_api_url. Asegúrate de que al menos una fuente de mercado (Yadio, CoinGecko, Currency API, Blockchain.com…) esté habilitada, o tu nodo no tendrá tasa fiat y rechazará toda orden a precio de mercado. Revisa en el log de arranque las advertencias que empiezan con price:.

4.11 Otros Bloques Opcionales

Más bloques que puedes encontrar en una plantilla nueva. Ninguno es obligatorio. Tres de ellos tienen su propia sección: [price.providers.pegged] (4.12), [reputation_import] / [reputation_export] (4.13) y [health] (5.4). serbero_pubkey, en [mostro], se cubre en 5.10.

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] pide a los tomadores, a los creadores o a ambos que bloqueen una pequeña hold invoice Lightning junto a la operación. Los usuarios honestos la recuperan intacta; un solver puede castigar (slash) la fianza de quien actuó de mala fe, y una parte va a la contraparte honesta. Los usuarios la ven como un "depósito" en la app, y la documentación para usuarios la explica en su capítulo Anti-Abuse Bond. Todas las fases ya se publicaron; está deshabilitada por defecto.

[anti_abuse_bond]
enabled = true
amount_pct = 0.01                 # fianza = max(1% de la orden, base_amount_sats)
base_amount_sats = 1000
apply_to = "take"                 # "take" | "make" | "both"
slash_on_waiting_timeout = false  # castiga también a quien deja vencer su paso
slash_node_share_pct = 0.5        # parte de una fianza castigada que se queda el nodo
payout_claim_window_days = 15     # tiempo que tiene el ganador para reclamar su parte
maker_bond_payment_timeout_seconds = 900
# bond_cltv_delta = 432           # mira abajo

Lee el docs/ANTI_ABUSE_BOND.md del proyecto antes de habilitarlo en un nodo en producción, y anúncialo antes a tus usuarios.

Historial del pagador (experimental)

[payer_history] combate la estafa de triangulación, en la que un comprador paga desde la cuenta bancaria de un tercero. El comprador se compromete con un hash de la cuenta desde la que pagará (declare-payer), el vendedor puede compararlo con el remitente que figura en su estado de cuenta, y Mostro guarda solo un HMAC. A partir de v0.20.2 solo la declaración está conectada: el requisito require_declaration y el historial que se muestra a los vendedores todavía no están implementados, y ningún cliente publicado envía declare-payer. Déjalo apagado por ahora.

# [payer_history]
# enabled = false
# require_declaration = false

Escrow con Cashu

[cashu] es un modo experimental que funciona sin LND y mantiene el escrow de las operaciones en tokens Cashu. Todavía no sirve para operar de verdad — las acciones de la operación posteriores a la toma siguen siendo rechazadas — y no se puede combinar con las fianzas anti-abuso. Desde v0.19.3 el creador elige la mint por orden a partir de una lista permitida:

# [cashu]
# enabled = false
# mint_urls = ["https://mint.example.com"]   # [] vacío = cualquier mint con host público
# escrow_locktime_days = 15

La antigua clave única mint_url se rechaza: una config que todavía la tenga no carga.

4.12 Stablecoins y Bitcoin en Otras Redes

Desde v0.20.2 un nodo puede ofrecer operaciones contra seis códigos que no son monedas fiat: stablecoins en dólares, y bitcoin en otras redes. Los sats Lightning siempre son uno de los lados de la operación; el otro lado se paga on-chain, en Liquid, en Rootstock o en la red de la stablecoin, directamente entre los dos usuarios.

CódigoQué esSe cotiza comoMonto de la orden en
USDTTether USD1 USDmonedas enteras
USDCUSD Coin1 USDmonedas enteras
DOCDollar on Chain (Rootstock)1 USDmonedas enteras
BTCBitcoin on-chain1 sat = 1 satsats
LBTCL-BTC en Liquid1 sat = 1 satsats
RBTCRBTC en Rootstock1 sat = 1 satsats

Cómo habilitarlo

Necesitas mostrod v0.20.2 o posterior. Dos ajustes trabajan juntos: fiat_currencies_accepted dice qué códigos pueden usar las órdenes, y el proveedor pegged dice cuáles de ellos tienen precio de mercado.

[mostro]
# Conserva tus monedas fiat y agrega los códigos nuevos, en MAYÚSCULAS
fiat_currencies_accepted = ['USD', 'EUR', 'USDT', 'USDC', 'DOC', 'LBTC', 'RBTC']

# Una fuente de precio de mercado para fiat (y por tanto para las stablecoins).
# Obligatoria en v0.20.2 en cuanto agregas cualquier tabla [price.providers.*].
[price.providers.yadio]
enabled = true
url = "https://api.yadio.io"

[price.providers.pegged]
enabled = true
only = ["USDT", "USDC", "DOC", "LBTC", "RBTC"]   # o except = ["BTC"]; sin ninguno, los seis

Reinicia Mostro y revisa el log. Si ves price: the pegged provider quotes ... but fiat_currencies_accepted does not list them, agrega los códigos que faltan: un código cotizado que no está aceptado publica una tasa pero rechaza todas las órdenes. Un fiat_currencies_accepted = [] vacío acepta todos los códigos.

⚠️ No agregues solo el bloque pegged en v0.20.2

Cualquier tabla [price.providers.*] cambia el nodo al motor de precios multifuente y descarta el bitcoin_price_api_url heredado. En v0.20.2 una tabla pegged sin una fuente de mercado a su lado deja al nodo sin tasas fiat: todas las órdenes de mercado en USD, EUR y USDT se rechazan. Habilita siempre al menos una fuente de mercado, como en el ejemplo de arriba. (La próxima versión conserva automáticamente la fuente Yadio heredada en ese caso.) En v0.20.1 o anterior, no agregues el bloque en absoluto: el proveedor no existe allí.

Solo precio fijo. Para aceptar un código sin cotizarlo a mercado, lístalo en fiat_currencies_accepted y déjalo fuera de only. Los usuarios tienen entonces que fijar un monto de sats. Es una elección sensata para BTC on-chain, donde las comisiones de red hacen incómodas las órdenes pequeñas a precio de mercado.

Lo que ven tus usuarios

La Mostro App 2.1.2 y posteriores muestra estos códigos en el selector de moneda bajo Stablecoins y Bitcoin en otras redes, pero solo los que acepta tu nodo. Los montos de BTC, LBTC y RBTC se ingresan en sats. El método de pago nombra la red (USDT (Tron), USDC (Base), DOC (Rootstock), LBTC (Liquid)…), el vendedor comparte una dirección de recepción en el chat de la operación, y el comprador pega ahí el ID de la transacción después de pagar. Mostro nunca verifica la red ni la dirección. Por ahora mostro-cli y Mostrix solo pueden crear órdenes de precio fijo en estos códigos.

Las disputas necesitan otra evidencia

Informa a tus solvers antes de habilitar esto. No hay estado de cuenta bancario: la evidencia es el ID de transacción pegado en el chat, que el solver verifica en un explorador de bloques de esa red. En Liquid el comprador debe compartir el enlace sin cegar (unblinded), porque Liquid oculta los montos. Las transferencias son irreversibles, un pago en la red equivocada puede perderse, y el comprador paga la comisión de red: el vendedor debe recibir el monto completo. El vendedor debe liberar solo después de que la transferencia se confirme. El plazo es el mismo que para fiat (unos 120 bloques con los valores por defecto, mira 4.5), así que una transferencia on-chain con comisión baja puede no llegar a tiempo.

💡 Si una stablecoin pierde su paridad

Todavía no hay una protección automática contra la pérdida de paridad (depeg). Si USDT o USDC se aleja de un dólar, quítala de only, o agrégala a except si no usas only (déjala en fiat_currencies_accepted si aún quieres órdenes de precio fijo) y reinicia.

4.13 Importación y Exportación de Reputación

Los usuarios pueden traer a tu nodo la reputación que ganaron en otro lugar — en el bot de Telegram @lnp2pBot o en otro nodo Mostro —, para que un trader que se muda no empiece de cero. Viajan tres cifras: la cantidad de calificaciones recibidas, la calificación promedio y la fecha de la primera operación. Llegan como una attestation (atestación): un pequeño evento Nostr (kind 38388) firmado por la fuente, dirigido a la identidad del usuario y válido por 7 días. Tu nodo las suma a la reputación propia del usuario, y las contrapartes ven una sola cifra combinada.

Ambas direcciones son opt-in y están desactivadas por defecto. La importación necesita mostrod v0.20.0 o posterior; la exportación, v0.20.1 o posterior. Los usuarios necesitan la Mostro App en modo reputación: en modo de privacidad total no hay una identidad que lleve una reputación.

Importar desde lnp2pBot

lnp2pBot firma las atestaciones con una clave dedicada. Agrégala a tu lista de confianza:

[reputation_import]
enabled = true
max_lifetime_seconds = 604800   # la atestación más duradera que aceptas (7 días; máximo 30)

[[reputation_import.issuers]]
name = "lnp2pbot"               # nunca renombres una entrada que ya tenga importaciones
keys = ["000004ac730537f1cf7d91f4f584a498a530a0205d35e816ebbaf23aec61e459"]
# npub1qqqqftrnq5mlrnmaj860tp9ynzjnpgpqt567s9hthter4mrpu3vsrta3em

Reinicia Mostro. Tu evento de info (kind 38385) ahora lleva una etiqueta reputation_import_issuers, que es como la app sabe que puede ofrecer la importación en tu nodo. Varios nodos de la comunidad ya confían en esta clave.

El bot exporta una cuenta con al menos 10 operaciones completadas y 5 calificaciones recibidas que no esté baneada. El usuario empieza desde la app (Configuración → Red → Reputación → Importar reputación → Obtenerla de lnp2pBot), confirma en Telegram que el npub coincide y pega de vuelta el mensaje que le envía el bot.

Confiar en otro nodo Mostro

Un nodo que exporta anuncia su clave de firma en la etiqueta reputation_issuer de su evento de info. Léela con el comando de 5.4 (busca esa etiqueta), confírmala con el operador y agrega una entrada para ella:

[[reputation_import.issuers]]
name = "mostro-example"         # un nombre local estable que tú elijas
keys = ["<that node's reputation_issuer key, npub or hex>"]

Un usuario puede importar una vez desde cada fuente en cada nodo, y el usuario no puede deshacer la importación. Las cifras son una instantánea: las calificaciones posteriores en la fuente no se reflejan.

Exportar desde tu nodo

La exportación permite que tus usuarios lleven a otro nodo la reputación que ganaron en el tuyo. Solo viajan las calificaciones recibidas en tu nodo, nunca las importadas. El usuario necesita 10 operaciones completadas y 5 calificaciones recibidas en tu nodo, y no debe estar baneado.

Las atestaciones se firman con una clave dedicada, nunca con la clave de tu nodo. Genera una y guárdala junto al nsec, en el entorno o en <config-dir>/.env:

# Estructura de Docker Hub; usa tu propio directorio de configuración en otro caso
echo "MOSTRO_REPUTATION_ISSUER_SK=$(openssl rand -hex 32)" >> ~/mostro-config/.env
sudo chown 1000:1000 ~/mostro-config/.env
chmod 600 ~/mostro-config/.env
[reputation_export]
enabled = true
issuer_key_env = "MOSTRO_REPUTATION_ISSUER_SK"
lifetime_seconds = 604800       # de 1 a 604800 (7 días)

Mostro se niega a arrancar si la variable falta o no es válida, si contiene la clave propia de tu nodo, o si su clave pública también está en tu lista de [reputation_import]. Una vez que funciona, tu evento de info lleva la etiqueta reputation_issuer: comparte esa clave con los operadores que quieran confiar en tu nodo. Respalda la clave junto con tus otros secretos. Si se filtra, cualquiera puede emitir atestaciones a nombre de tu nodo hasta que los demás operadores la quiten y revoquen las importaciones.

Revocar importaciones y reasignar exportaciones

Dos llamadas RPC de administración (4.7) cubren los casos raros. Se aceptan solo desde loopback; agrega -H 'authorization: Bearer <token>' si configuraste auth_token. Ejecútalas desde un checkout del repositorio mostro, que contiene proto/admin.proto.

Se filtró la clave de un emisor de confianza. Primero quita la clave de su entrada y reinicia; luego revierte todas las importaciones firmadas con ella (agrega "imported_after": <unix time> para limitarlo a las recientes):

grpcurl -plaintext -import-path proto -proto admin.proto \
  -d '{"issuer_key": "<npub or hex>", "reason": "key leaked"}' \
  127.0.0.1:50051 mostro.admin.v1.AdminService/RevokeReputationImports

Cada importación se revierte exactamente, se conservan las calificaciones recibidas desde entonces, y los usuarios pueden volver a importar con una atestación de la clave nueva.

Un usuario perdió la identidad a la que está atada su exportación. La primera exportación ata la cuenta a una identidad; moverla normalmente requiere una autorización firmada con la identidad anterior, que la app produce. Si la identidad anterior ya no existe, puedes moverla tú mismo después de verificar a la persona:

grpcurl -plaintext -import-path proto -proto admin.proto \
  -d '{"identity": "<old npub>", "new_identity": "<new npub>", "reason": "support ticket"}' \
  127.0.0.1:50051 mostro.admin.v1.AdminService/RebindReputationExport

Un usuario que restaura las mismas 12 palabras conserva la misma identidad y no necesita nada de esto.

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 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. Con las fianzas anti-abuso habilitadas (4.11), el árbitro también puede castigar la fianza de quien actuó de mala fe.

El árbitro escribe a cada parte en un chat privado de la disputa, que la Mostro App muestra en Chat → Disputas. Cualquiera de las partes también puede compartir con el árbitro la clave del chat de su operación, y entonces el árbitro lee esa conversación en la pestaña Observer de Mostrix o en Bosstro. Las partes todavía pueden terminar la operación por su cuenta: si el vendedor libera, o ambos acuerdan una cancelación cooperativa, Mostro cierra la disputa por sí mismo y se lo avisa al árbitro.

Si ejecutas Serbero (5.10), este alerta a tus árbitros en cuanto se abre una disputa y puede dar los primeros pasos con las partes. Nunca decide ni mueve fondos.

⚠️ Importante

Elige a tus árbitros con cuidado. Tienen el poder de decidir a dónde van los fondos bloqueados. Elige miembros de confianza e imparciales de la comunidad. Se recomiendan 2-3 árbitros.

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.

Registrado comoPuedeNo puede
npub1...:readTomar una disputa, leerla, escribir a ambas partesLiquidar o cancelar la orden
npub1...:read-writeTodo, incluido liquidar y cancelar—

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. Un solver read-write puede tomar una disputa que tenga retenida uno de solo lectura (o Serbero).

Tus árbitros pueden trabajar desde una terminal con Mostrix (5.2) o desde un teléfono Android con Bosstro (5.11).

5.2 Mostrix — Tu herramienta de administración

Mostrix es un cliente Mostro de terminal (TUI) con dos modos: un modo usuario para operar, y un modo admin para resolver disputas — tomar disputas, chatear con ambas partes, liquidar o cancelar, castigar fianzas y agregar solvers. Si ejecutas un nodo Mostro, necesitas Mostrix. Habla con tu nodo solo por Nostr, nunca por la interfaz RPC.

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 y 5, SO de 64 bits)
wget https://github.com/MostroP2P/mostrix/releases/latest/download/mostrix-aarch64-unknown-linux-musl

# Linux (ARMv7 / Raspberry Pi OS de 32 bits)
wget https://github.com/MostroP2P/mostrix/releases/latest/download/mostrix-armv7-unknown-linux-gnueabi

# macOS (Apple Silicon / Intel)
curl -LO https://github.com/MostroP2P/mostrix/releases/latest/download/mostrix-aarch64-apple-darwin
curl -LO https://github.com/MostroP2P/mostrix/releases/latest/download/mostrix-x86_64-apple-darwin

# FreeBSD: mostrix-x86_64-unknown-freebsd
# Windows: descarga mostrix-x86_64-pc-windows-msvc.exe desde la página de releases

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

🔐 Verifica la Release

Verifica siempre el binario antes de ejecutarlo. Importa las claves de los mantenedores 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

Las firmas son archivos separados llamados manifest.txt.sig.<mantenedor>. Las releases recientes traen solo manifest.txt.sig.arkanoider (clave 2E98 6CA1 C5E7 EA16 35CD 059C 4989 CC74 15A4 3AEC), así que revisa la página de la release y descarga las que realmente estén listadas:

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
# (las líneas del manifest llevan un prefijo artifact-<target>/, que aquí se quita)
sed 's#  artifact-[^/]*/#  #' manifest.txt | sha256sum -c --ignore-missing

Una firma válida de una clave de mantenedor en la que confíes es suficiente. Si un wget devuelve 404, esa firma simplemente no se publicó para esa release: no tomes un archivo ausente como uno verificado.

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; Mostrix necesita 1.97 o posterior)
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 crea ~/.mostrix/ con una base de datos que guarda una semilla nueva de 12 palabras y un settings.toml, y luego muestra una ventana Backup New Keys con las 12 palabras. Anótalas. Un settings.toml colocado junto al binario tiene prioridad (modo portable).

⚠️ Importante: Apunta Mostrix a tu nodo

La configuración generada apunta al nodo público por defecto de Mostro. Cámbiala a tu propio nodo: Settings → Select Mostro Instance, y pega el npub o hex de tu nodo, o edita mostro_pubkey en ~/.mostrix/settings.toml y reinicia.

Para el modo admin (resolución de disputas), las claves relevantes son:

# ~/.mostrix/settings.toml
mostro_pubkey = "YOUR_MOSTRO_PUBKEY"         # hex o npub
nsec_privkey  = "nsec1..."                   # tu identidad de trader, derivada de la semilla — no la edites
admin_privkey = "nsec1..."                   # la clave de un solver registrado — ver abajo
relays = ["wss://relay.mostro.network"]
currencies_filter = []                       # vacío = mostrar todas las monedas
user_mode = "admin"                          # o Settings → Switch Mode
# trusted_dm_senders = ["npub1..."]          # npub de Serbero, para ver sus reportes (5.10)
⚠️ ¿Qué clave va en admin_privkey?

Mostro acepta acciones de disputa de su propia clave (el nsec_privkey del daemon) y de las claves de solvers registrados. Cualquier otra clave es rechazada. Solo la clave del daemon puede agregar solvers, así que úsala solo para eso y mantenla en el servidor. Para el trabajo diario con disputas, registra una clave de solver — read-write para liquidar o cancelar — y pon esa en admin_privkey. Nunca reutilices nsec_privkey.

ADMIN_NSEC=nsec1<daemon-key> MOSTRO_PUBKEY=<node-npub> \
  RELAYS=wss://relay.mostro.network \
  mostro-cli admaddsolver -n npub1solver...

La opción Settings → Add Dispute Solver de Mostrix hace lo mismo, con Izquierda/Derecha para elegir Read o Read-Write (por defecto Read-Write).

El modo admin en la práctica

5.3 mostro-watchdog — Alertas de Telegram para disputas y salud del nodo

mostro-watchdog es un bot de Telegram para tu equipo de administración. Vigila tu nodo por Nostr y publica en un grupo o canal privado:

Opción A: script de instalación (recomendada). Descarga la última versión, la verifica contra manifest.txt e instala en /usr/local/bin:

curl -fsSL https://raw.githubusercontent.com/MostroP2P/mostro-watchdog/main/install.sh | bash
# o en otro directorio:
curl -fsSL https://raw.githubusercontent.com/MostroP2P/mostro-watchdog/main/install.sh | bash -s -- --install-dir ~/.local/bin

Opción B: descarga manual del binario

# Linux x86_64 (Intel/AMD); usa mostro-watchdog-linux-aarch64 en ARM64
curl -LO https://github.com/MostroP2P/mostro-watchdog/releases/latest/download/mostro-watchdog-linux-x86_64
curl -LO https://github.com/MostroP2P/mostro-watchdog/releases/latest/download/manifest.txt
sha256sum -c manifest.txt --ignore-missing
chmod +x mostro-watchdog-linux-x86_64
sudo mv mostro-watchdog-linux-x86_64 /usr/local/bin/mostro-watchdog

Los binarios para macOS y Windows también están en la página de releases.

Opción C: compilar desde código fuente

sudo apt install -y cmake pkg-config libssl-dev
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

El watchdog guarda su estado (disputes.db) junto a config.toml, así que dale un directorio propio:

sudo useradd --system --home-dir /var/lib/mostro-watchdog --shell /usr/sbin/nologin mostro-watchdog
sudo install -d -o mostro-watchdog -g mostro-watchdog -m 700 /var/lib/mostro-watchdog
curl -LO https://raw.githubusercontent.com/MostroP2P/mostro-watchdog/main/config.example.toml
sudo install -o mostro-watchdog -g mostro-watchdog -m 600 config.example.toml /var/lib/mostro-watchdog/config.toml
sudo nano /var/lib/mostro-watchdog/config.toml
[mostro]
pubkey = "YOUR_MOSTRO_PUBKEY"         # hex o npub

[nostr]
# Relays de arranque: el watchdog lee la lista de relays de tu nodo (NIP-65)
# desde ellos, y luego sigue los relays que tu nodo anuncia.
relays = ["wss://relay.mostro.network", "wss://nos.lol"]

[telegram]
bot_token = "YOUR_BOT_TOKEN"          # de @BotFather
chat_id = -1001234567890              # tu grupo o canal de administración

[health]
info_silence_threshold = 900          # 3 × el publish_mostro_info_interval de Mostro (300 por defecto)
mostro_health_enabled = true          # necesita Mostro v0.20.0+
event_alert_threshold = 0             # ver abajo

Para encontrar el chat_id, agrega el bot al grupo, envía un mensaje ahí y abre https://api.telegram.org/bot<TOKEN>/getUpdates.

La antigua alerta de "silencio de eventos" salta cada vez que no llega ningún evento de disputa en dos horas, lo que en la mayoría de los nodos es solo una tarde tranquila. Las verificaciones de info y de salud detectan un nodo detenido de forma fiable, así que 0 la desactiva.

La clave Nostr del watchdog

Los detalles de salud, las alertas de Serbero, los avisos a solvers y el latido (heartbeat) propio del watchdog necesitan una clave propia, que se pasa solo por el entorno:

sudo sh -c 'umask 077; echo "WATCHDOG_NOSTR_PRIVATE_KEY=$(openssl rand -hex 32)" > /etc/mostro-watchdog.env'

Respalda ese archivo. Al arrancar, el watchdog registra su clave pública. Ponla en el settings.toml de Mostro y reinicia Mostro, para que tu liquidez, los fallos de pago y la expiración de HTLCs se cifren solo para el watchdog:

[health]
watchdog_pubkey = "WATCHDOG_PUBKEY"   # hex o npub

Esto agrega una etiqueta p pública a tu evento de salud que vincula tu nodo con la clave del watchdog. Sin ella, el watchdog igual alerta sobre el estado público.

Ejecútalo como servicio

# /etc/systemd/system/mostro-watchdog.service
[Unit]
Description=mostro-watchdog
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
User=mostro-watchdog
WorkingDirectory=/var/lib/mostro-watchdog
EnvironmentFile=/etc/mostro-watchdog.env
ExecStart=/usr/local/bin/mostro-watchdog --config /var/lib/mostro-watchdog/config.toml
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target
sudo systemctl daemon-reload
sudo systemctl enable --now mostro-watchdog
journalctl -u mostro-watchdog -f

Opcional: Serbero y alertas a solvers

Agrega una sección vacía por cada una que quieras. Ambas usan la clave de arriba:

[serbero]                 # los pasos de Serbero en el mensaje de cada disputa
[solver_notifications]    # avisos privados a los solvers

Para Serbero, agrega también la clave pública hex del watchdog al config.toml de Serbero como observador (observer) — nunca como solver — y reinicia Serbero. Los observadores reciben una línea por paso, nunca lo que escribieron las partes. El watchdog encuentra a Serbero por su cuenta a través del serbero_pubkey de tu nodo (5.10).

[[observers]]
pubkey = "WATCHDOG_PUBKEY_HEX"

Para los avisos a solvers, cada solver envía /link al bot en un chat privado e ingresa el código en Mostrix 0.3.6 o posterior, en Settings → Link Watchdog. El bot responde a comandos solo en chats privados: /version, /link, /unlink, /status.

💡 Vigila al watchdog

Un canal en silencio no prueba que el watchdog esté vivo. Puedes ejecutar un segundo en otra máquina, cada uno con su propio WATCHDOG_NOSTR_PRIVATE_KEY y la clave pública del otro en [health].peer_watchdogs. Las alertas de salud también pueden ir a un chat aparte con [health].alerts_chat_id. El config.example.toml del proyecto documenta todas las opciones.

5.4 Monitoreo y salud del nodo

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

Funcionando no es lo mismo que sirviendo

En octubre de 2026 el LND de un nodo en producción dejó de seguir la cadena durante unas 21 horas. Mostro siguió corriendo y aceptando operaciones, pero todos los pagos a compradores fallaron. Una revisión del proceso, del puerto o un robot de uptime habrían mostrado verde todo el tiempo.

Desde v0.20.0 Mostro lo verifica por sí mismo. Cada minuto publica un evento de salud firmado (kind 38389) con un estado general (ok, degraded o down), un estado por cada verificación (lnd_sync, payouts, relays, database) y la altura de bloque de LND. Viene activado por defecto; este bloque solo muestra los valores por defecto:

[health]
enabled = true                  # publica el evento de salud (kind 38389)
interval = 60                   # segundos entre publicaciones, de 30 a 3600
watchdog_pubkey = ""            # la clave de tu watchdog: las métricas detalladas se cifran para ella (5.3)
lnd_unsynced_fail_after = 600   # debe ser mayor que 60
auto_maintenance_on_lnd_unsynced = true
lnd_resynced_clear_after = 300

Cuando LND deja de estar sincronizado, Mostro protege a tus usuarios por su cuenta:

El log cuenta la historia: LND reports synced_to_chain = false ...; outgoing payments wait after 60s, luego maintenance mode ON (reason lnd_unsynced), y después LND is synced to chain again y maintenance mode OFF. Revisa LND con lncli getinfo (synced_to_chain, block_height). Configura auto_maintenance_on_lnd_unsynced = false para desactivar el mantenimiento automático.

Mostro solo sabe lo que le dice su propio LND, y un nodo atascado en una cadena vieja no siempre se entera. Por eso los dos lectores de abajo comparan su altura de bloque con exploradores públicos:

La página de estado pública

La página (Semáforo) lee los eventos de salud directamente de los relays y los verifica en el navegador del visitante, sin backend. Cada nodo recibe un color:

ColorCuándo
🟢 OperationalEstado ok, un evento reciente, y LND a menos de 3 bloques de los exploradores
🟡 DegradedEstado degraded, modo mantenimiento, o sin una altura de bloque independiente con la cual comparar
🔴 DownEstado down, LND 3 o más bloques por detrás, o sin un evento válido reciente ("Not reporting")
⚪ Not monitoredListado, pero aún no se espera que publique

Bajo cada nodo, 90 barras diarias y una cifra de uptime provienen de muestras tomadas cada 10 minutos.

Cómo lograr que tu nodo aparezca. Solo se muestran nodos curados, porque cualquiera puede firmar un evento siempre en verde:

  1. Tu nodo está listado como comunidad en este sitio.
  2. Ejecuta Mostro v0.20.0 o posterior con el evento de salud activado, y publica en al menos uno de wss://relay.mostro.network, wss://mostro-p2p.tech o wss://relay.shadowbip.com.
  3. Abre un issue o pull request en MostroP2P/semaforo para agregarlo a trusted.json con su pubkey hex, nombre, región y red. Tu avatar se copia de la foto de perfil de tu perfil Nostr.

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, ajustes de fianzas, claves de Serbero y de reputación. Leerlo, junto con el evento de salud, 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
# Evento de info
nostreq --kinds 38385 --limit 1 --authors YOUR_MOSTRO_PUBKEY_HEX \
  | nostcat --stream wss://relay.mostro.network | jq
# Evento de salud: estado, verificaciones, altura de bloque de LND
nostreq --kinds 38389 --limit 1 --authors YOUR_MOSTRO_PUBKEY_HEX \
  | nostcat --stream wss://relay.mostro.network | jq '.tags'
💡 Las revisiones del host siguen sirviendo

Un ping al host (UptimeRobot o similar) todavía te avisa cuando la VPS misma es inalcanzable. No puede decirte si Mostro está pagando a los compradores; el evento de salud sí.

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: compáralo con el nuevo settings.tpl.toml. La mayoría de las funciones nuevas siguen apagadas hasta que las agregas, pero un bloque que falta toma sus valores por defecto, y algunos están activados (el evento de salud de 5.4, por ejemplo).
  2. Respalda la base de datos con los comandos de 5.6. Necesitas ese respaldo para volver atrás.
⚠️ Si vienes de v0.18.x

Revisa esto antes de iniciar la versión nueva, o puede negarse a arrancar:

  • Borra cualquier línea transport = "gift-wrap" (4.8). Los usuarios con clientes viejos de protocolo v1 tienen que actualizar.
  • escrow_deadline_margin_blocks debe ser al menos 18 y estar por debajo de hold_invoice_cltv_delta (4.9).
  • Bajo [cashu], mint_url pasó a ser mint_urls = [...] (4.11).
  • Con las fianzas anti-abuso activadas y un hold_invoice_cltv_delta de 288 o más, configura bond_cltv_delta explícitamente (4.11).
  • Desde v0.20.0 el evento de salud se publica por defecto, y Mostro puede entrar en mantenimiento por su cuenta cuando LND está desincronizado (5.4).

Docker Hub (docker run)

export MOSTRO_TAG=v0.20.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 restart no es una actualización

docker restart vuelve a arrancar el mismo contenedor, con la imagen con la que fue creado. Para correr una versión nueva hay que crear el contenedor otra vez: docker rm + docker run, o docker compose up -d después de cambiar el tag.

Docker Hub (Docker Compose)

export MOSTRO_TAG=v0.20.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.20.2
make docker-build
make docker-down
make docker-up

Nativo

cd /opt/mostro
git fetch --tags
git checkout v0.20.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.

⚠️ No cambies de nodo Lightning al mismo tiempo

Actualizar Mostro es seguro en cualquier momento. Apuntarlo a un nodo Lightning distinto no lo es: drena el escrow primero, mira 5.8.

5.6 Respaldos

Archivos críticos para respaldar: settings.toml, el archivo .env si guardas ahí tu nsec (ver 4.1) o tu clave de exportación de reputación (4.13), y mostro.db (historial de órdenes, reputación). Si habilitas el historial del pagador (4.11), guarda los respaldos de la base de datos separados del nsec: el historial está indexado con él.

⚠️ No copies una base de datos en uso con cp

SQLite funciona en modo WAL, así que las escrituras recientes viven en mostro.db-wal hasta que se consolidan. Copiar solo mostro.db mientras Mostro está corriendo puede producir un respaldo al que le falten las operaciones más nuevas. Usa el comando de respaldo propio de SQLite, que es seguro sobre una base en uso y escribe un único archivo consistente.

# 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)
cp /opt/mostro/docker/config/.env /root/mostro-backups/env.$(date +%Y%m%d) 2>/dev/null

# 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)
cp /opt/mostro/.env /root/mostro-backups/env.$(date +%Y%m%d) 2>/dev/null

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); cp /root/mostro-config/.env /root/mostro-backups/env.$(date +\%Y\%m\%d) 2>/dev/null

# 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); cp /opt/mostro/docker/config/.env /root/mostro-backups/env.$(date +\%Y\%m\%d) 2>/dev/null

# 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); cp /opt/mostro/.env /root/mostro-backups/env.$(date +\%Y\%m\%d) 2>/dev/null
⚠️ Crítico

Tu nsec_privkey en settings.toml ES la identidad de tu nodo. Si la pierdes, pierdes tu reputación y todos los usuarios deben reconectarse a una nueva identidad. Guarda una copia offline.

Si ejecutas tu propio LND

Los respaldos de Mostro no cubren tu nodo Lightning. Los fondos en tus canales dependen de dos respaldos de LND:

Nunca respaldes ni restaures channel.db como forma de recuperar canales: una copia desactualizada hace que tu nodo transmita estados antiguos, y los pares pueden quedarse con todos los fondos de esos canales. Los sistemas nodo-en-caja y Voltage tienen sus propias funciones de respaldo; actívalas. La documentación de LND cubre la recuperación en detalle (planificación de la recuperación).

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), y la llamada se acepta solo desde loopback: ejecútala en el host del nodo, o a través de ssh -N -L 50051:127.0.0.1:50051 user@node.

Mostro también puede entrar en mantenimiento por su cuenta, con el motivo lnd_unsynced, cuando LND se desincroniza (5.4). Si activas el mantenimiento mientras eso está en curso, pasa a ser tuyo y el daemon no lo levantará; no puedes usar lnd_unsynced como tu propio motivo.

  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.
⚠️ allow_node_change

Ponlo en true solo para recuperación de desastres, cuando el nodo viejo se perdió definitivamente. Deja a sabiendas las operaciones afectadas sin resolver. Mover el mismo nodo a otro host no es un cambio de nodo y no necesita nada de esto.

5.9 Comandos de Operador con mostro-cli

Mostrix es la forma cómoda de trabajar las disputas, y mostro-cli cubre lo básico desde una terminal, además de algunos comandos de operador que Mostrix no tiene. 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. La CLI no lee ningún archivo de configuración: define tu nodo y tus relays en el entorno, y pon los flags globales antes del subcomando.

# Trabajo de disputas (por Nostr)
export MOSTRO_PUBKEY=npub1...            # tu nodo
export RELAYS=wss://relay.mostro.network
export ADMIN_NSEC=nsec1...
mostro-cli listdisputes
mostro-cli admtakedispute -d <dispute-id>     # muestra las pubkeys del comprador y del vendedor
mostro-cli getadmindm -s 120
mostro-cli admsenddm -p <party-pubkey> -m "mensaje a una parte"
mostro-cli admsettle -o <order-id> [--slashseller] [--slashbuyer]   # liberar al comprador
mostro-cli admcancel -o <order-id> [--slashseller] [--slashbuyer]   # reembolsar al vendedor

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

Los flags de castigo solo importan con fianzas anti-abuso (4.11). Fíjate en la ortografía: --slashseller, no --slash-seller. admsenddm envía un mensaje directo desde la clave admin; no es el chat por disputa que usan la Mostro App, Mostrix y Bosstro, así que prefiere esos clientes para hablar con las partes.

Otro grupo de comandos va por el gRPC de administración en lugar de Nostr, así que necesitan la interfaz RPC habilitada (ver 4.7) en vez de ADMIN_NSEC. MOSTRO_RPC_URL es por defecto http://127.0.0.1:50051, y MOSTRO_RPC_TOKEN solo hace falta si configuraste auth_token.

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 una fianza, 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.

mostro-cli todavía no tiene comandos para la importación y exportación de reputación, el historial del pagador ni el evento de salud: usa grpcurl para las RPC de reputación (4.13) y los comandos de 5.4 para el evento de salud. Instálalo con cargo install mostro-cli (Rust 1.97 o posterior) o toma un binario de sus releases; ejecuta mostro-cli <command> --help para ver todos los flags.

5.10 Serbero — Asistente de disputas

Serbero es un asistente opcional para las disputas de tu nodo. Lo ejecutas junto a Mostro, con una clave Nostr propia. Hace dos trabajos:

Serbero nunca mueve fondos y nunca decide una disputa. Mostro lo registra como un solver de solo lectura, así que no puede liquidar ni cancelar, y cualquier solver read-write puede tomar una disputa de sus manos en cualquier momento. Si Serbero está caído, Mostro y tus solvers funcionan exactamente como antes. Mantén al menos un solver humano read-write.

Instalación

Cada release trae binarios para Linux (x86_64, aarch64) y macOS (Apple silicon), cada uno con un archivo SHA-256. Los nombres de archivo llevan la versión:

V=$(curl -fsSL https://api.github.com/repos/MostroP2P/serbero/releases/latest | grep -m1 '"tag_name"' | cut -d'"' -f4)
A=serbero-$V-x86_64-unknown-linux-gnu        # aarch64-unknown-linux-gnu en ARM64
curl -LO https://github.com/MostroP2P/serbero/releases/download/$V/$A.tar.gz
curl -LO https://github.com/MostroP2P/serbero/releases/download/$V/$A.tar.gz.sha256
shasum -a 256 -c $A.tar.gz.sha256
tar -xzf $A.tar.gz && cd $A        # serbero, config.sample.toml, deploy/

Con Rust instalado, cargo install serbero --locked también funciona. Una imagen Docker (ghcr.io/mostrop2p/serbero) y un archivo compose se describen en el README del proyecto.

Configuración

cp config.sample.toml config.toml
nano config.toml
[serbero]
private_key_env = "SERBERO_PRIVATE_KEY"   # nombra el secreto; la clave nunca va en este archivo
db_path = "serbero.db"

[mostro]
pubkey = "YOUR_MOSTRO_PUBKEY_HEX"
relays = ["wss://relay.mostro.network", "wss://nos.lol"]   # relays en los que publica tu nodo

# Una entrada por solver humano: la pubkey hex de la clave que usa su cliente
# (Mostrix: admin_privkey). Nunca listes la clave propia de Serbero.
[[solvers]]
pubkey = "SOLVER_PUBKEY_HEX"
permission = "write"

[notify]
renotify_after = "15m"

[mediation]
enabled = false

Ejecútalo como servicio

El proyecto incluye una unidad systemd endurecida. Descárgala de main: la copia dentro del archivo de v0.2.5 necesita systemd 251 y no arranca en Ubuntu 22.04.

sudo useradd --system --home-dir /var/lib/serbero --shell /usr/sbin/nologin serbero
sudo install -m 755 serbero /usr/local/bin/serbero
sudo install -d -m 755 /etc/serbero
sudo install -m 644 config.toml /etc/serbero/config.toml
sudo install -d -m 700 /etc/serbero/credentials
sudo sh -c 'umask 077; openssl rand -hex 32 > /etc/serbero/credentials/serbero_private_key'
curl -fsSLO https://raw.githubusercontent.com/MostroP2P/serbero/main/deploy/serbero.service
sudo install -m 644 serbero.service /etc/systemd/system/serbero.service
sudo systemctl daemon-reload && sudo systemctl enable --now serbero
journalctl -u serbero -f        # anota el npub que registra al arrancar

Respalda /etc/serbero/credentials/serbero_private_key sin conexión. Es la identidad de Serbero: si la pierdes, tendrás que registrar un npub nuevo.

Regístralo en tu nodo

Mostro v0.19.1 o posterior registra a Serbero por ti. Agrega su npub al bloque [mostro] de tu settings.toml y reinicia Mostro:

[mostro]
serbero_pubkey = "npub1..."   # la clave de Serbero, npub o hex

Al arrancar, Mostro registra esa clave como solver de solo lectura y la anuncia en su evento de info. Ese anuncio es como la Mostro App etiqueta los mensajes de Serbero y como mostro-watchdog lo encuentra. El log lo confirma: Serbero npub1... configured: registered as a read-only solver.

⚠️ No agregues a Serbero con admaddsolver

Un npub pelado agregado con admaddsolver queda como read-write (5.1), y entonces Mostro se niega a arrancar con REFUSING TO START: serbero_pubkey ... is a solver with write permission. También rechaza una clave que pertenece a un usuario que no es solver, y la clave propia de tu nodo. Dale a Serbero una clave propia y deja que serbero_pubkey lo registre.

Tus solvers leen a Serbero en Mostrix

Mostrix 0.3.5 o posterior muestra los mensajes de Serbero en un panel SERBERO por cada disputa, pero solo de los remitentes en los que el solver confía. En el ~/.mostrix/settings.toml de cada solver:

trusted_dm_senders = ["npub1..."]   # npub de Serbero

La pubkey del admin_privkey del solver debe ser exactamente la de una entrada [[solvers]], y Mostrix debe leer al menos uno de los relays de Serbero. Para tomar un caso, pulsa Ctrl+T en un traspaso; requiere permiso read-write, y Serbero deja de escribir de inmediato. Bosstro (5.11) todavía no muestra los resúmenes de Serbero.

Activar la mediación (piloto)

La mediación viene apagada. Cuando está activa, Serbero toma cada nueva disputa y se presenta a ambas partes como un asistente automatizado, en su idioma (inglés, español o portugués), con una pregunta corta a la vez. Cuando ambos han respondido, les da 30 minutos para resolver la operación por su cuenta y luego entrega el caso a tus solvers. Nunca le dice a nadie que libere o cancele.

Para leer las respuestas, Serbero consulta a un modelo juez (Jev de TypeSafe) en tu propia cuenta de pago. El juez recibe los roles de la operación, el monto, la moneda y el método de pago, y el texto del mensaje — nunca claves públicas. Pide al proveedor cero retención de datos, y avisa a tus usuarios que los mensajes de disputa los procesa un servicio automatizado. El README explica la clave de API y la tabla de umbrales; configura enabled = true bajo [mediation] y reinicia, y el log dice mediation ready o por qué no.

Los mensajes de las partes son eventos kind 14: usa más de un relay, y solo relays que los almacenen, o los mensajes enviados mientras Serbero está desconectado se pierden. Para publicar el avance de Serbero en el Telegram de tu equipo, registra mostro-watchdog como observador (5.3). Respalda serbero.db de forma privada: contiene las conversaciones de las disputas.

5.11 Bosstro — Resolver disputas desde el teléfono

Bosstro es la app Android para solvers de disputas. Lleva el lado admin de Mostrix a un teléfono: un solver ve las disputas pendientes de tu nodo, toma una, chatea con el comprador y el vendedor (incluidas imágenes y PDFs), lee el chat propio de las partes cuando una de ellas comparte su clave y, con permiso read-write, paga al comprador o devuelve al vendedor, con la opción de fianza cuando tu nodo tiene fianzas.

Es una herramienta para tus solvers, no para operar, y nunca guarda la clave de tu nodo. Registrar solvers sigue haciéndose desde Mostrix o mostro-cli (5.2).

Instalar y verificar

Android 7.0 o posterior. Descarga el APK desde GitHub Releases: arm64-v8a para casi cualquier teléfono, armeabi-v7a para uno viejo de 32 bits. Compáralo con el archivo de checksums de la release:

sha256sum -c SHA256SUMS.txt --ignore-missing

El checksum solo prueba que la descarga está completa. El certificado de firma prueba quién la compiló, y Android rechaza una actualización firmada con cualquier otra clave. Compáralo con AppVerifier:

foundation.mostro.bosstro
63:92:27:84:C2:E3:2A:F4:B6:03:0F:5E:2A:18:1F:74:9B:F6:95:E5:2F:1C:A8:45:7E:98:CB:05:D2:9E:B3:4B

Agregar un solver

  1. El solver abre Bosstro, toca Create new account (o Log in con un nsec de solver existente) y te envía el npub. Esa clave no debe usarse para nada más — nunca la clave de una app de trading, o ambos roles quedan vinculados en público.
  2. Tú lo registras, de solo lectura para empezar (5.1):
    ADMIN_NSEC=nsec1... mostro-cli admaddsolver -n npub1solver...:read
  3. El solver elige tu nodo en Bosstro: Mostro, una comunidad de la lista, o tu propia pubkey y relays. Bosstro averigua por las respuestas de tu nodo si la clave es un solver y con qué permiso.
⚠️ Límites actuales

Bosstro habla solo protocolo v2 (4.8). La versión 0.1 no muestra los resúmenes de traspaso de Serbero y todavía no tiene notificaciones push, así que los solvers que trabajan con Serbero aún necesitan Mostrix para eso. Un solver read-write puede tomar una disputa de Serbero en Bosstro.

6. Desglose de Costos

Costos operativos mensuales

ConceptoCosto mensualNotas
VPS (servidor)$10–24Depende del proveedor y las especificaciones
Nombre de dominio (opcional)$1–2Para un sitio web/identidad
Comisiones on-chain de canales LightningVariableApertura/cierre de canales
Total mensual$11–26Excluyendo liquidez Lightning

Costos únicos / de capital

ConceptoCostoNotas
Liquidez Lightning0.01–1.0+ BTCBloqueado en canales; se recupera al cerrar
Hardware del nodo (si se auto-aloja)$0–600Gratis si usas VPS; $300-600 para Start9/Umbrel
Tiempo de configuración4–16 horasDependiendo del nivel de experiencia

Potencial de ingresos

Volumen mensualComisión (0.6%)Comisión dev (30%)Tu ingreso neto
$1,000~$6~$1.80~$4.20
$10,000~$60~$18~$42
$50,000~$300~$90~$210
$100,000~$600~$180~$420
📝 Realidad

La mayoría de los nodos nuevos tardan meses en construir volumen de operaciones. No esperes rentabilidad inmediata. El valor real suele venir de proporcionar un servicio a tu comunidad, con las comisiones como bonus.

Compromiso de tiempo

TareaFrecuenciaTiempo
Monitoreo (revisar logs, estado)Diario5–10 min
Resolución de disputasSegún necesidad15–60 min por disputa
ActualizacionesMensual15–30 min
Gestión de liquidezSemanal15–30 min
Estimación semanal total1–3 horas

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?

Mucha gente ejecuta LND en una Raspberry Pi 4 o 5 con un SSD, a través de Start9, Umbrel o RaspiBlitz, y el paquete Mostro de StartOS puede correr a su lado. Para un nodo del que depende tu comunidad, un VPS es más confiable que una conexión y una fuente de energía caseras. Un punto medio común es LND en casa y Mostro en un VPS, enlazados por una VPN (ver 2.2).

¿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 un cliente Mostro — la Mostro App para Android, iOS, escritorio y web, o mostro-cli o Mostrix — y la clave pública de tu Mostro (npub). En la app van a Configuración → Red → Nodo Mostro → Agregar nodo propio y pegan tu npub; los nodos listados en este sitio ya aparecen ahí. El cliente se comunica a través de relays Nostr. No se necesita conexión directa.

¿Puede mi nodo seguir atendiendo clientes viejos (protocolo v1)?

No. Desde v0.19.0 Mostro habla solo protocolo v2 (4.8). Los usuarios con un cliente viejo tienen que actualizar a la Mostro App o a un Mostrix o mostro-cli actual.

¿Pueden mis usuarios operar USDT, Liquid o Rootstock en lugar de fiat?

Sí, desde v0.20.2: USDT, USDC, DOC, BTC on-chain, LBTC y RBTC. Los habilitas uno por uno, y tus solvers deben saber cómo verificar esas transferencias. Mira 4.12.

¿Pueden los usuarios traer su reputación de lnp2pBot u otro Mostro?

Sí, si confías en la fuente. Activa la importación de reputación y agrega la clave de lnp2pBot, o la de un nodo Mostro en el que confíes (4.13). También puedes permitir que tus usuarios exporten la reputación que ganaron en tu nodo.

¿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. Si es tu LND el que se desincroniza mientras Mostro sigue corriendo, los pagos esperan en lugar de fallar y, pasados 10 minutos, el nodo entra en mantenimiento por su cuenta hasta que LND se recupere (5.4).

¿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

⚠️ Aviso de software en etapa temprana

Mostro está en una etapa temprana de desarrollo. Aunque el equipo trabaja duro para asegurar confiabilidad, puede haber bugs no descubiertos — incluyendo bugs de seguridad que podrían resultar en pérdida de fondos. Los desarrolladores no son responsables de ninguna pérdida de dinero debido a bugs de software.

Mostro es open-source y su código está abierto a auditorías. Animamos a las comunidades a promover y financiar auditorías de seguridad independientes.

Dicho esto, el mecanismo central de custodia usando hold invoices de Lightning ha sido probado en batalla desde 2021, cuando @lnp2pBot implementó por primera vez este tipo de custodia. Miles de operaciones han sido completadas exitosamente.

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. Tu evento de info publica la pubkey de LND y las direcciones que anuncia, así que haz que LND anuncie solo direcciones Tor.
  5. Sabe qué publica tu nodo. El evento de salud (5.4) es público: estado, altura de bloque de LND y red, versión de Mostro. Configurar un watchdog_pubkey agrega una etiqueta que vincula tu nodo con esa clave. Desactívalo con [health] enabled = false si eso te importa más que el monitoreo.
  6. Las variables de proxy no bastan. Las consultas de direcciones Lightning ignoran deliberadamente HTTP_PROXY/HTTPS_PROXY. Para ocultar la IP del servidor, enruta toda la máquina por Tor o una VPN.
💡 Consejo

La belleza de que Mostro sea descentralizado es que incluso si un nodo es apagado, otros siguen funcionando. Pero la prevención siempre es mejor que la recuperación. Toma la privacidad en serio desde el primer día.

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

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.

transport = "gift-wrap" (protocol v1) is no longer supported

Borra la línea transport de settings.toml. Mira 4.8.

escrow_deadline_margin_blocks (X) must be at least 18 ... o ... must be below hold_invoice_cltv_delta

Configura el margen entre 18 y hold_invoice_cltv_delta; el 24 de la plantilla con 144 funciona. Mira 4.9.

unknown field mint_url

En [cashu], renómbrala a mint_urls = ["..."]. Mira 4.11.

anti_abuse_bond.bond_cltv_delta ... must be above hold_invoice_cltv_delta + 144 o ... must be at most 864

Configura bond_cltv_delta explícitamente dentro de esos límites. En v0.20.2, las fianzas más un hold_invoice_cltv_delta de 288 o más chocan con esto con el valor por defecto. Mira 4.11.

REFUSING TO START: serbero_pubkey ...

La clave de Serbero ya es un solver read-write, pertenece a un usuario, o es la clave propia de tu nodo. Dale a Serbero una clave propia. Mira 5.10.

Los ajustes de reputación impiden el arranque

Los nombres de emisor deben ser únicos y cada clave válida y listada una sola vez; la clave de un emisor nunca debe pasar a otro nombre una vez que tiene importaciones. Con la exportación activada, MOSTRO_REPUTATION_ISSUER_SK debe estar definida, ser válida, distinta de la clave de tu nodo y no estar en tu propia lista de importación. Mira 4.13.

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

Tu nodo habla solo protocolo v2. Un usuario con un cliente viejo que solo habla protocolo v1 no recibe respuesta y debe actualizar (4.8). Revisa también que los clientes y tu nodo compartan al menos un relay.

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

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

Pagos fallando

Los pagos no salen, pero no hay ningún error

Revisa si LND está sincronizado: lncli getinfo. Mientras no lo esté, Mostro retiene los pagos a propósito y los reenvía cuando LND se recupera (5.4).

Los usuarios reciben rechazos por "mantenimiento" aunque nunca lo activé

mostro-cli admmaintenancestatus muestra el motivo. lnd_unsynced significa que Mostro lo activó porque LND se desincronizó; lo levanta solo 5 minutos después de que LND vuelve a estar sincronizado (5.4).

Nunca se pagan los dev fees

En testnet, signet o regtest es lo esperado: los dev fees se pagan solo en mainnet (4.2).

Se rechazan las órdenes a precio de mercado en una moneda

Tu nodo no tiene tasa para ella. Revisa las advertencias price: en el log de arranque: un bloque [price] sin ninguna fuente de mercado habilitada, o una stablecoin cotizada pero no listada en fiat_currencies_accepted, son las causas habituales. Mira 4.10 y 4.12.

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

ArchivoDocker HubNativo
Configuración~/mostro-config/settings.toml/opt/mostro/settings.toml
Base de datos~/mostro-config/mostro.db/opt/mostro/mostro.db
Cert LND~/mostro-config/lnd/tls.certVaría (revisar config LND)
Macaroon LND~/mostro-config/lnd/mostro.macaroonVaría (revisar config LND)
ServicioN/A/etc/systemd/system/mostro.service
Logsdocker logs -f mostrojournalctl -u mostro

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

Esta guía es mantenida por la comunidad Mostro. ¿Encontraste un error o quieres mejorarla?
Las contribuciones son bienvenidas en github.com/MostroP2P/community

Última actualización: Octubre de 2026 · Mostro v0.20.2