Eseguire il Tuo Nodo Mostro

Mostro v0.20.2 — Guida della Comunità · Ottobre 2026

1. Cos'è Mostro e perché la tua comunità dovrebbe eseguirne uno?

Mostro è un exchange peer-to-peer di Bitcoin che permette alle persone di comprare e vendere Bitcoin utilizzando valute locali (dollari, euro, pesos — qualsiasi valuta) senza dover fornire documenti d'identità (KYC). Pensalo come un marketplace decentralizzato dove acquirenti e venditori possono commerciare direttamente.

Funziona utilizzando due tecnologie:

Mostro agisce come un coordinatore di custodia — trattiene i Bitcoin del venditore in una "cassaforte" temporanea (chiamata hold invoice) fino a quando l'acquirente conferma di aver inviato il pagamento in valuta locale. Mostro non controlla mai realmente i fondi di nessuno; li trattiene solo brevemente durante lo scambio.

Perché la tua comunità vorrebbe eseguire un nodo Mostro?

  1. Entrate da commissioni — Ogni operazione ti genera la commissione che hai impostato (il template parte da 0; lo 0,6% è una scelta comune). Con lo 0,6%, una comunità che fa $10.000 in operazioni mensili guadagna ~$60/mese in commissioni.
  2. Trading P2P senza KYC — I membri della tua comunità possono comprare e vendere Bitcoin senza fornire documenti d'identità. Particolarmente importante in regioni con valute instabili o regolamentazioni restrittive.
  3. Dispute nella tua lingua — Quando un'operazione va storta, la tua comunità la risolve, nella tua lingua, comprendendo i tuoi metodi di pagamento locali.
  4. Indipendenza — Nessuna azienda può chiudere il tuo exchange. Nessun governo può fare pressione su un singolo operatore per chiuderlo.
  5. Personalizzazione — Tu scegli quali valute supportare, quali metodi di pagamento consentire e quali commissioni applicare.

Come funziona Mostro (Semplificato)

1. Alice vuole VENDERE Bitcoin per $50 USD → Crea un ordine su Mostro
2. Bob vuole COMPRARE Bitcoin con $50 USD → Vede l'ordine di Alice e lo prende
3. Mostro crea una "cassaforte" (hold invoice) → Alice invia i suoi Bitcoin nella cassaforte
4. Bob invia $50 ad Alice tramite bonifico, Zelle, contanti, ecc. → Bob preme "Fiat Inviato" nella sua app
5. Alice conferma di aver ricevuto i $50 → Preme "Rilascia"
6. Mostro rilascia i Bitcoin dalla cassaforte a Bob → Operazione completata! ✓

Se qualcosa va storto (es: Bob dice di aver pagato ma Alice non ha ricevuto), una delle parti può aprire una disputa, e gli arbitri assegnati della tua comunità indagano e risolvono.

2. Prerequisiti — Cosa ti serve prima di iniziare

2.1 Un Server (VPS)

Un VPS (Virtual Private Server) è un computer in un data center che funziona 24/7. Ne affitterai uno per ospitare il tuo nodo Mostro.

Specifiche minime:

RisorsaMinimoRaccomandato
CPU2 vCPU (condivise)2+ vCPU
RAM2 GB4 GB
Storage60 GB SSD100 GB SSD
Banda3 TB/mese3+ TB/mese
SOUbuntu 22.04+ LTSUbuntu 24.04 LTS

Costo mensile stimato: $10–$24/mese.

Queste cifre valgono per il solo Mostro. Se LND gira sullo stesso VPS, aggiungi almeno 2 GB di RAM e il disco che serve al suo backend Bitcoin (vedi 2.2).

Provider VPS popolari:

💡 Consiglio

Molti provider VPS accettano pagamenti in Bitcoin. Cerca questa opzione se vuoi mantenere coerenza con la filosofia Bitcoin.

Devi sentirti a tuo agio nel connetterti a un server tramite SSH. Se non l'hai mai fatto, cerca un tutorial su "Connettersi via SSH a un VPS" — è più semplice di quanto sembri.

2.2 Un Nodo Lightning Network (LND)

Lightning Network è un sistema "layer 2" costruito su Bitcoin che permette pagamenti rapidi e economici. Per eseguire Mostro, hai bisogno di un nodo LND (Lightning Network Daemon) — il software Lightning specifico con cui Mostro lavora.

Le tue opzioni:

OpzioneDifficoltàCostoNote
Usare un nodo LND esistenteFacileGratis (se ne hai uno)Meglio se qualcuno ne ha già uno
Eseguire LND sullo stesso VPSDifficileVPS più grande + liquidità4GB+ RAM e disco per il backend Bitcoin (vedi sotto)
Soluzione nodo-in-a-boxMedio$200-600 + liquiditàStart9, Umbrel, RaspiBlitz
StartOS con pacchetto MostroPiù facile$300-600 + liquiditàStart9 ha un pacchetto Mostro con un clic
Usare Voltage.cloudFacileDa ~$20/mese + liquiditàVoltage — LND ospitato con infrastruttura gestita
⚠️ Importante

Mostro richiede specificamente LND (non CLN/Core Lightning, non Eclair, non LDK). Assicurati che il tuo nodo Lightning esegua LND.

Cosa ti serve dal tuo nodo LND:

Genera un macaroon dedicato per Mostro. Non dare a Mostro il tuo admin.macaroon: concede il controllo totale sul tuo nodo e sui suoi fondi. Crea un macaroon che contenga solo i permessi che Mostro usa davvero (leggere le info del nodo, elencare i canali per il report di salute, creare/regolare/annullare hold invoice, inviare e tracciare pagamenti).

Scegli prima un root key ID non ancora in uso. Revocare un macaroon revoca tutti i macaroon che condividono il suo ID, quindi riutilizzarne uno porterebbe via credenziali estranee. L'ID 0 appartiene ai macaroon di LND, quindi scegli un numero libero diverso da zero e annotalo:

lncli listmacaroonids

Poi crea il macaroon con l'ID che hai scelto (7 in questo esempio, sostituisci con il tuo):

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

Questo macaroon non può aprire o chiudere canali, spostare fondi on-chain né modificare la configurazione del tuo nodo. Se dovesse trapelare, revocalo con lncli deletemacaroonid 7, usando lo stesso ID con cui l'hai creato, e generane uno nuovo.

Se non puoi scrivere nella directory dati di LND (un container, un nodo-in-a-box, un nodo ospitato), ometti --save_to: lncli stamperà allora il macaroon in esadecimale, e lo trasformi in un file dove gira Mostro. lncli può anche generarlo da un'altra macchina, puntata al nodo con le sue credenziali 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 l'esadecimale che stampa, poi:
echo "PASTE_THE_HEX_HERE" | xxd -r -p > mostro.macaroon   # apt install -y xxd se manca

A differenza di Mostro, lncli verifica che NODE_ADDRESS compaia nel certificato del nodo. LND vi inserisce gli indirizzi della macchina quando lo crea, ma non, per esempio, un indirizzo VPN aggiunto dopo. Se la connessione fallisce con un errore di certificato, esegui lncli sul nodo stesso, oppure aggiungi l'indirizzo con tlsextraip (o tlsextradomain) in lnd.conf, elimina tls.cert e tls.key e riavvia LND perché crei un nuovo certificato; poi copia anche il nuovo tls.cert su Mostro.

Come si connette Mostro a LND

Mostro parla con la porta gRPC di LND (10009 per impostazione predefinita) e si autentica con tls.cert e il macaroon. Ci sono tre cose da sapere prima di scegliere dove far girare LND:

LND sullo stesso VPS

Installa LND seguendo la guida ufficiale (docs.lightning.engineering), usando i suoi binari di release. LND ha bisogno di una vista della blockchain Bitcoin, e questa scelta decide la dimensione del tuo VPS:

BackendDiscoCompromesso
bitcoind, nodo completoPiù di 700 GBIl più robusto. La sincronizzazione iniziale richiede giorni.
bitcoind, prunedDecine di GBSupportato da LND e robusto; la sincronizzazione iniziale richiede comunque giorni.
neutrinoPochi GBNessun nodo Bitcoin e avvio rapido, ma dipende dai peer da cui si sincronizza. Un nodo neutrino rimasto bloccato per circa 21 ore è il motivo per cui Mostro ora monitora la sincronizzazione di LND (5.4). Se lo usi, puntalo a nodi Bitcoin di cui ti fidi con neutrino.connect e configura gli avvisi di salute.

Poi rendi LND raggiungibile da Mostro. Con l'installazione nativa (Opzione C) non cambia nulla: usa https://127.0.0.1:10009. Con Docker (Opzioni A e B) il container è un host separato, quindi scegli una di queste strade:

LND su un altro server o a casa

Collega le due macchine con una VPN come WireGuard o Tailscale, fai ascoltare LND sul suo indirizzo VPN (rpclisten=VPN_IP:10009, più rpclisten=localhost:10009 perché lncli continui a funzionare sul nodo: qualsiasi riga rpclisten sostituisce quella predefinita) e imposta lnd_grpc_host = 'https://VPN_IP:10009'. Copia tls.cert e il macaroon sul server di Mostro. Aprire la porta 10009 a internet funziona comunque, ma allora il macaroon è l'unica cosa che separa il mondo dal tuo nodo: evitalo. Un nodo a casa deve restare online 24/7: un blackout o una connessione che cade lasciano in attesa gli scambi dei tuoi utenti.

Nodo-in-a-box (Start9, Umbrel, RaspiBlitz)

Questi sistemi installano e aggiornano LND per te, di solito su un piccolo computer a casa. Su StartOS la via più semplice è il pacchetto Mostro stesso, che si collega al servizio LND sulla stessa box. Usare l'LND della box da un Mostro su un VPS è più difficile: questi sistemi gestiscono da sé la configurazione di LND, quindi potresti non riuscire ad aggiungere una riga rpclisten, e spesso espongono gRPC solo sulla rete locale o via Tor, che Mostro non può usare. Verifica cosa consente il tuo sistema prima di pianificarlo. Ogni sistema mostra i dettagli di connessione di LND nella propria interfaccia (su StartOS, nelle proprietà del servizio LND); lncli di solito gira dentro il container di LND, su Umbrel per esempio sudo docker exec -it lightning_lnd_1 lncli ... (controlla il nome con sudo docker ps). Genera il macaroon in esadecimale come mostrato sopra.

Voltage (LND ospitato)

Voltage gestisce LND per te. Scarica tls.cert e il macaroon admin dalla dashboard del nodo, usali solo per generare il macaroon limitato di Mostro dalla tua macchina (vedi sopra) e punta lnd_grpc_host all'indirizzo gRPC che mostra la dashboard, porta 10009. La liquidità resta da fornire e gestire a te.

Impostazioni di LND che influenzano Mostro

2.3 Liquidità Lightning

Per facilitare le operazioni, il tuo nodo Lightning ha bisogno di canali con Bitcoin al loro interno. Pensa ai canali Lightning come tunnel di pagamento pre-finanziati. I Bitcoin all'interno di questi canali sono la tua "liquidità".

Quanta ne serve?

Volume di trading obiettivoLiquidità suggeritaBTC approssimativi
Comunità piccola (poche operazioni/giorno)1–5 milioni di sat0,01–0,05 BTC
Comunità media5–20 milioni di sat0,05–0,20 BTC
Comunità attiva20–100 milioni di sat0,20–1,0 BTC
💡 Nota sulla Liquidità Lightning

I Bitcoin nei tuoi canali Lightning sono bloccati onchain ma restano altamente spendibili via Lightning Network. Molti servizi accettano pagamenti Lightning — dai bar ai provider VPS — rendendo la tua liquidità piuttosto flessibile per l'uso quotidiano.

Inizia in piccolo, cresci gradualmente. Inizia con quanto basta per le esigenze iniziali della tua comunità e monitora il feedback. Quando i trader segnalano ordini falliti per capacità insufficiente, quello è il tuo segnale per aggiungerne di più. Ascolta la tua comunità.

Ottenere liquidità:

2.4 Chiavi Nostr

Il tuo nodo Mostro ha bisogno della propria identità sulla rete Nostr — una coppia di chiavi crittografiche con una chiave pubblica (l'indirizzo del tuo nodo) e una chiave privata (il tuo segreto).

⚠️ Importante

Non riutilizzare mai le chiavi Nostr tra istanze di Mostro. Ogni nodo ha bisogno della propria identità unica.

Generare chiavi Nostr sicure localmente con rana:

# Installare Rust (se non già installato)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# Installare rana - generatore locale di chiavi Nostr
cargo install rana

# Generare una nuova coppia di chiavi (con frase seed di 12 parole)
rana --generate 12

Rana genererà la tua chiave privata (nsec), chiave pubblica (npub) e una frase seed di backup. Conserva tutto in modo sicuro! Nota: eseguire rana senza argomenti avvia il mining PoW (difficoltà 10) che può richiedere minuti — usa --generate per la generazione istantanea. Non generare mai chiavi importanti usando servizi online.

2.5 Livello di conoscenza tecnica

AttivitàDifficoltàConoscenze necessarie
Affittare un VPSFacileCarta di credito, navigazione web di base
Connettersi via SSHFacileSeguire istruzioni, digitare comandi
Installare DockerMedioCopiare e incollare comandi, risoluzione problemi di base
Eseguire Mostro (Docker)MedioModificare file di configurazione, capire i percorsi
Eseguire Mostro (nativo)DifficileAmministrazione Linux, compilazione software, systemd
Configurare LND da zeroDifficileConoscenza significativa di Linux e reti
Gestire la liquidità LightningDifficileComprendere l'economia dei canali Lightning

💡 Il nostro consiglio: Se la tua comunità ha qualcuno a proprio agio con la riga di comando Linux, può gestire l'installazione con Docker. La compilazione nativa richiede esperienza di amministrazione di sistema. La configurazione del nodo Lightning è la parte più complessa — considera di chiedere aiuto a qualcuno con esperienza, o di usare una soluzione nodo-in-a-box.

3. Installazione Passo per Passo

Tutte le opzioni di installazione condividono gli stessi primi passaggi. Poi scegli l'opzione che preferisci:

Tutte presuppongono che tu abbia già: ✅ Un VPS con Ubuntu · ✅ Accesso SSH · ✅ Un nodo LND funzionante.

Passaggi Comuni (per tutte e 3 le opzioni)

Passo 1: Connettiti al tuo VPS

ssh root@IL_TUO_INDIRIZZO_IP_VPS

Passo 2: Aggiorna il sistema

# Scaricare le informazioni più recenti sui pacchetti
apt update

# Installare tutti gli aggiornamenti disponibili
apt upgrade -y

Passo 3: Installare Docker e Docker Compose

💡 Nota

Docker è necessario per le opzioni A e B. Se compili manualmente (Opzione C), puoi saltare questo passaggio.

# Installare Docker con lo script ufficiale
curl -fsSL https://get.docker.com | sh

# Verificare che Docker sia installato
docker --version

# Verificare Docker Compose
docker compose version

Passo 4: Installare strumenti aggiuntivi

apt install -y git make

✅ Passaggi comuni completati. Ora scegli la tua opzione di installazione:

Opzione A: Docker Hub (La più veloce — Raccomandata)

Esegui Mostro direttamente da Docker Hub senza clonare il repository o compilare. Perfetto per deployment su VPS.

Passo 5: Creare la directory di configurazione

mkdir -p ~/mostro-config/lnd

Passo 6: Ottenere il template di configurazione

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

Passo 7: Copiare le credenziali LND

cp /percorso/del/tuo/tls.cert ~/mostro-config/lnd/tls.cert
cp /percorso/del/tuo/mostro.macaroon ~/mostro-config/lnd/mostro.macaroon

Se LND è sulla stessa macchina, i percorsi tipici sono:

Passo 8: Modificare la configurazione

nano ~/mostro-config/settings.toml

Modifiche necessarie:

[lightning]
lnd_cert_file = '/config/lnd/tls.cert'
lnd_macaroon_file = '/config/lnd/mostro.macaroon'
lnd_grpc_host = 'https://host.docker.internal:10009'  # Se LND sullo stesso VPS
# O usare 'https://IL_TUO_IP_LND:10009' se LND su server diverso

[database]
url = "sqlite:///config/mostro.db"  # mostrod usa sempre <directory-di-config>/mostro.db

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

[mostro]
fee = 0.006                    # 0,6% commissione per operazione
max_order_amount = 1000000     # Ordine massimo in sat
min_payment_amount = 100       # Ordine minimo in sat
fiat_currencies_accepted = ['USD', 'EUR']  # Le tue valute

Salvare: Ctrl+X, poi Y, poi Invio.

Passo 9: Impostare i permessi

⚠️ Importante

Evita chmod 777. Usa permessi minimi.

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

Passo 10: Eseguire il container

Se LND è sullo stesso VPS (LND deve accettare la connessione del container, oppure usa la rete host: vedi 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

Se LND è su un server diverso:

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

Passo 11: Controllare i log

docker logs -f mostro

Cerca questi messaggi:

💡 Nota

Non esiste un messaggio "connesso a LND" né "connesso al relay". Mostro contatta LND durante l'avvio, quindi un daemon che supera l'avvio ha raggiunto LND. Il fallimento invece è rumoroso: registra Ln node error e termina. Dopo l'avvio interroga LND ogni 15 secondi e registra LND did not answer GetInfo se smette di rispondere; i pagamenti in uscita restano in attesa finché non torna (5.4). Per i relay, il segnale è la riga dell'evento di salute: No relay accepted the health event significa che nessuno lo ha accettato.

💡 Risoluzione problemi

Se vedi Permission denied (os error 13), riapplica i permessi: chown -R 1000:1000 ~/mostro-config e riavvia: docker restart mostro.

🎉 Congratulazioni! Se vedi connessioni riuscite nei log, il tuo nodo Mostro è in funzione!

Alternativa: Docker Compose

Invece di un lungo comando docker run puoi descrivere il container in un file compose. Esegue la stessa immagine con le stesse impostazioni, e aggiornare diventa cambiare il tag su una riga. 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 se LND gira su questo VPS
    volumes:
      - ${HOME}/mostro-config:/config

Avvialo e segui i log:

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

Scegline uno: docker run oppure compose, non entrambi. Per aggiornare l'uno o l'altro, vedi 5.5.

🔒 Nota di Sicurezza

Usa sempre un tag di versione specifico (es. mostrop2p/mostro:v0.20.2) invece di :latest per controllare i deployment.

Opzione B: Docker Build (Costruire l'immagine localmente)

Passo 5: Scaricare Mostro

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

Passo 6: Configurare i file

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

Passo 7: Modificare il file di configurazione

nano config/settings.toml

Modifica le stesse impostazioni dell'Opzione A, Passo 8, con una differenza: make docker-build copia il tuo macaroon in config/lnd/admin.macaroon, qualunque fosse il nome originale, quindi punta Mostro lì:

lnd_macaroon_file = '/config/lnd/admin.macaroon'  # è sempre il tuo mostro.macaroon ristretto, con un altro nome
⚠️ Se LND gira sulla stessa VPS

A differenza dell'Opzione A, il docker/compose.yml del repository non mappa host.docker.internal, quindi su Linux quel nome non si risolve dentro il container. Aggiungi il mapping al servizio mostro prima di compilare:

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

Oppure punta lnd_grpc_host all'IP locale dell'host. Nota che make docker-build compila anche l'immagine StartOS, che una VPS non necessita: costa solo tempo di compilazione.

Passo 8: Costruire l'immagine Docker

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

Passo 9: Avviare Mostro

# Avvia Mostro e il relay incluso. `make docker-up` da solo avvia
# anche l'immagine StartOS, che su una VPS non serve.
docker compose -f docker/compose.yml up -d mostro nostr-relay

# Controlla lo stato
docker compose -f docker/compose.yml ps

# Vedi i log
docker compose -f docker/compose.yml logs -f mostro

🎉 Congratulazioni! Se vedi connessioni riuscite, il tuo nodo Mostro è in funzione!

Opzione C: Compilazione Nativa (Per operatori tecnici)

Passo 5: Installare Rust

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

NON installare Rust tramite apt install rustc. Usa sempre rustup. Il pacchetto di sistema è spesso obsoleto.

Passo 6: Installare le dipendenze di compilazione

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

Passo 7: Scaricare e compilare Mostro

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

Se la compilazione fallisce per mancanza di RAM, aggiungi spazio swap:

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

Passi 8–10: Installare, inizializzare e pulire

install target/release/mostrod /usr/local/bin
cargo clean  # Risparmia 2+ GB di spazio

Passi 11–12: Creare utente e configurare

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

Modifica le stesse impostazioni dell'Opzione A, Passo 8.

Passi 13–15: Test, permessi e servizio systemd

# Test di esecuzione
/usr/local/bin/mostrod -d /opt/mostro

# Impostare i permessi
chown -R mostro:mostro /opt/mostro
💡 La procedura guidata interattiva

Se esegui mostrod senza un settings.toml nella directory indicata e sei su un terminale, ti propone un menu di configurazione che può costruire il file per te e scrivere il nsec in un .env. Senza terminale (Docker, systemd, CI) copia il template, stampa dove l'ha messo e termina perché tu lo modifichi.

Creare il servizio 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

🎉 Congratulazioni! Il tuo nodo Mostro è in esecuzione come servizio di sistema.

4. Configurazione in Dettaglio

Il file settings.toml controlla tutto del tuo nodo Mostro.

4.1 Chiavi Nostr — L'identità del tuo nodo

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

Quali relay usare?

💡 Consiglio

Puoi anche far girare il tuo relay Nostr accanto a Mostro. La via Docker Build (Opzione B) ne include uno nel suo compose.yml; l'Opzione A e la compilazione nativa no.

Tenere la chiave fuori da settings.toml

Mostro legge la chiave anche dalla variabile d'ambiente MOSTRO_NSEC_PRIVKEY. La precedenza è: variabile d'ambiente, poi <directory-di-config>/.env, poi settings.toml.

# ~/mostro-config/.env  (chmod 600) — caricato automaticamente all'avvio
MOSTRO_NSEC_PRIVKEY=nsec1...

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

# Unità systemd
Environment="MOSTRO_NSEC_PRIVKEY=nsec1..."

Lasciare nsec_privkey in settings.toml funziona ancora. Se usi il file .env, fanne il backup con la stessa cura della configurazione.

4.2 Commissioni — Come generi entrate

[mostro]
fee = 0.006
dev_fee_percentage = 0.30

Commissione di trading (fee): Percentuale addebitata per operazione, divisa tra acquirente e venditore.

Esempio: In un'operazione da 100.000 sat con fee = 0.006: L'acquirente paga 300 sat, il venditore paga 300 sat, il tuo nodo guadagna 600 sat in totale.

Commissione di sviluppo (dev_fee_percentage): Una percentuale delle tue entrate da commissioni che va allo sviluppo di Mostro.

📝 Nota

Impostare dev_fee_percentage sotto 0.10 impedirà a Mostro di avviarsi. Questo minimo assicura un finanziamento sostenibile dello sviluppo.

4.3 Limiti degli ordini e valute

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

4.4 Profilo del nodo (Opzionale ma raccomandato)

[mostro]
name = "LatAm Mostro"
about = "Exchange P2P di Bitcoin per l'America Latina. Supporto in spagnolo."
picture = "https://esempio.com/il-tuo-logo.png"
website = "https://sito-della-tua-comunita.com"

Questi configurano il profilo del tuo Mostro su Nostr (NIP-01 kind 0 metadata). I client mostrano queste informazioni affinché gli utenti sappiano su quale Mostro stanno operando.

4.5 Tempi e scadenza

[mostro]
expiration_hours = 24        # Quanto tempo un ordine non preso resta nel book
max_expiration_days = 15     # Scadenza massima che un maker può chiedere
expiration_seconds = 900     # Quanto può attendere un ordine preso la hold invoice
                             # o la fattura dell'acquirente prima di tornare nel book (15 min)

[lightning]
hold_invoice_expiration_window = 300  # Tempo che ha il taker per pagare la fattura o fornirne una di incasso (5 min)
hold_invoice_cltv_delta = 144         # Durata dell'escrow, in blocchi (~1 giorno)

Nota che hold_invoice_expiration_window appartiene a [lightning]: scritto sotto [mostro] viene ignorato in silenzio. Deve essere maggiore di 0, ed è anche la scadenza della fattura della cauzione di un taker.

Una volta bloccati i sat del venditore, l'acquirente ha circa hold_invoice_cltv_delta - escrow_deadline_margin_blocks blocchi per inviare il pagamento: 144 − 24 = 120 blocchi, circa 20 ore, con i valori predefiniti. Allo scadere, Mostro annulla l'operazione se l'acquirente non ha mai segnato il pagamento come inviato, oppure apre una disputa se lo ha fatto (vedi 4.9). Gli utenti vedono il conto alla rovescia nell'app.

4.6 Anti-Spam

[mostro]
pow = 0  # 0 = disabilitato; 10-20 = moderato. Inizia con 0.

Un filtro più fine è pow_first_contact. pow si applica a ogni messaggio, mentre pow_first_contact si applica solo ai mittenti estranei a un'operazione attiva e viene verificato prima della decifratura. Così le operazioni in corso restano economiche mentre agli sconosciuti costa lavoro reale:

[mostro]
pow = 0                  # operazioni in corso
pow_first_contact = 16   # nuovi ordini e prese da chiavi sconosciute

I client devono minare almeno quel valore. Chi usa mostro-cli deve impostare POW (o -p) al tuo valore, altrimenti i nuovi ordini e le prese vengono scartati senza risposta.

Un deterrente più forte contro chi prende ordini e poi sparisce è la cauzione anti-abuso (vedi 4.11).

4.7 Interfaccia RPC di Amministrazione (Opzionale)

[rpc]
enabled = false
listen_address = "127.0.0.1"
port = 50051
# auth_token = "una-stringa-lunga-e-casuale"

Questa interfaccia gRPC serve agli strumenti dell'operatore: grpcurl, e mostro-cli per la modalità manutenzione (admsetmaintenance, admmaintenancestatus, admcancelpending). Mostrix non la usa: lavora su Nostr, quindi non ti serve l'RPC per risolvere le dispute.

⚠️ Sicurezza

Mantieni listen_address su "127.0.0.1" e non esporre mai la porta a internet. Imposta auth_token ogni volta che la porta è raggiungibile da qualcosa che non sia la macchina locale, come un tunnel SSH o un container sidecar: una connessione inoltrata arriva come loopback, quindi l'indirizzo di ascolto da solo non è autorizzazione. Con un token impostato, ogni chiamata che modifica lo stato deve portare l'header authorization: Bearer <token>.

Oltre alla modalità manutenzione, l'RPC espone le chiamate di reputazione RevokeReputationImports e RebindReputationExport (vedi 4.13). Entrambe sono accettate solo da loopback e mostro-cli non ha ancora un comando per loro: usa grpcurl. mostro-cli invia MOSTRO_RPC_TOKEN solo a un indirizzo loopback o su https://, mai in chiaro a un host remoto.

4.8 Protocollo di Trasporto

Dalla v0.19.0 un nodo Mostro parla solo il protocollo v2: eventi kind 14 firmati con contenuto cifrato NIP-44. Il protocollo v1 (gift wrap NIP-59, kind 1059) è stato rimosso e non c'è più nulla da scegliere. Lascia fuori la riga transport da settings.toml; il template non ce l'ha più.

Riga in settings.tomlRisultato
nessunaProtocollo v2. Raccomandato.
transport = "nip44"Protocollo v2. Accettata e innocua.
transport = "gift-wrap"Mostro si rifiuta di partire, con un errore che ti dice di eliminare la riga.

Il tuo nodo annuncia protocol_version 2 nel suo evento info kind 38385. Tutti i client attuali parlano v2: la Mostro App, Mostrix 0.3.1 o successivo, mostro-cli 0.16.2 o successivo e Bosstro. Un client che parla solo v1, come una vecchia build di Mostro Mobile, non riceve alcuna risposta dal tuo nodo: chiedi ai tuoi utenti di aggiornare.

⚠️ Aggiornamento dalla v0.18.x

Se il tuo settings.toml dice ancora transport = "gift-wrap", elimina quella riga prima di aggiornare. L'unico modo per continuare a servire i client protocollo v1 è restare su mostrod 0.18.x, che non riceve più correzioni.

4.9 Limiti di Sicurezza Lightning

Queste impostazioni di [lightning] limitano quanto a lungo i tuoi canali possono restare bloccati e quanti pagamenti possono essere irrisolti contemporaneamente. Hanno tutte un valore predefinito, quindi un file di configurazione di una versione precedente di solito si avvia ancora, ma un template nuovo le include e vale la pena conoscerle.

[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
ImpostazioneCosa protegge
max_final_cltv_expiry_deltaRifiuta una fattura di pagamento il cui CLTV finale permetterebbe al beneficiario di trattenere i tuoi sat troppo a lungo. 144 blocchi (circa un giorno) è il massimo che chiedono i wallet reali. Non impostarlo mai a 0: rifiuterebbe ogni fattura.
escrow_deadline_margin_blocksMargine di sicurezza prima che LND annulli automaticamente una hold invoice accettata. Quando la catena si avvicina a questo punto, Mostro annulla l'operazione o apre una disputa mentre l'escrow esiste ancora. Dalla v0.20.0 Mostro si rifiuta di partire a meno che non sia almeno 18 (il valore predefinito di LND per invoices.holdexpirydelta, 12, più 6 blocchi di margine) e inferiore a hold_invoice_cltv_delta. Se hai alzato holdexpirydelta, mantieni tu questo margine ad almeno 6 blocchi sopra. Il valore è pubblicato nel tuo evento info.
max_inflight_payoutsTetto ai pagamenti irrisolti su tutto il nodo, così un beneficiario che non liquida mai non può esaurire i tuoi slot HTLC. Un pagamento frenato viene ritardato, mai scartato.
max_inflight_payouts_per_destinationLo stesso tetto per pubkey di destinazione, ed è il più efficace dei due.
payment_cltv_limitTetto al timelock totale di una rotta di pagamento. Non deve superare --max-cltv-expiry del tuo LND e deve stare almeno 576 blocchi sopra max_final_cltv_expiry_delta, altrimenti i pagamenti legittimi falliscono con "no route".
allow_node_changeGuardia all'avvio in caso di cambio di nodo Lightning. Lascialo su false e vedi 5.8.

Nota anche che max_routing_fee, nel blocco [mostro], ora ha come default 0.002 (0,2%).

4.10 Fonti del Prezzo di Bitcoin

Mostro ha bisogno di un tasso BTC/fiat per quotare gli ordini. Senza un blocco [price] usa una sola fonte, Yadio, tramite il ormai deprecato bitcoin_price_api_url. Aggiungere il blocco ti dà più fonti, combinate per mediana e con scarto dei valori anomali, così un'API caduta o che restituisce un numero sbagliato non muove i tuoi prezzi.

[price]
update_interval_seconds = 300
max_price_staleness_seconds = 1800
outlier_threshold_pct = 5.0        # scarta una fonte a questa distanza dalla mediana (servono 3+ fonti)
provider_timeout_seconds = 10
provider_failure_threshold = 3     # fallimenti prima di mettere una fonte in pausa
provider_failure_cooldown_seconds = 120
publish_to_nostr = true            # pubblica i tassi aggregati come 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"              # opzionale, alza i limiti di frequenza

[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 tasso ufficiale, non mischiare con fonti informali

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

Ogni fonte accetta only o except per limitare a quali valute contribuisce, e fallback_urls per mirror provati quando la URL principale fallisce. Una fonte abilitata a cui manca un segreto richiesto fallisce all'avvio invece di non produrre silenziosamente alcuna quotazione.

💡 Se le API di prezzo sono bloccate nel tuo paese

Puoi prendere i tassi da Nostr invece che via HTTP, pubblicati da nodi Mostro di cui ti fidi. Riusa i relay già presenti in [nostr], quindi funziona dovunque il tuo nodo raggiunga già un relay. Con più nodi fidati vince l'evento valido più recente.

[price.providers.nostr]
enabled = true
trusted_nodes = [
    # pubkey hex dei nodi Mostro di cui ti fidi per tassi accurati
]

Gli operatori che servono il peso cubano possono aggiungere El Toque per CUP e MLC del mercato informale. È opt-in, limitato a queste due valute, e richiede un token gratuito: un El Toque abilitato senza token si rifiuta di partire.

Mantieni publish_to_nostr = true. Oltre ad alimentare gli altri nodi, i tassi pubblicati dicono alla Mostro App quali valute il tuo nodo sa quotare a prezzo di mercato: un codice che manca da lì viene offerto solo a prezzo fisso. Per quotare le stablecoin e bitcoin su altre reti, vedi 4.12.

⚠️ Aggiungere qualsiasi blocco [price] cambia il motore dei prezzi

Appena settings.toml ha una tabella [price] o [price.providers.*], Mostro usa il motore multi-fonte e ignora bitcoin_price_api_url. Assicurati che almeno una fonte di mercato (Yadio, CoinGecko, Currency API, Blockchain.com…) sia abilitata, altrimenti il tuo nodo non ha un tasso fiat e rifiuta ogni ordine a prezzo di mercato. Controlla nel log di avvio gli avvisi che iniziano con price:.

4.11 Altri Blocchi Opzionali

Altri blocchi che potresti incontrare in un template recente. Nessuno è obbligatorio. Tre di loro hanno una sezione dedicata: [price.providers.pegged] (4.12), [reputation_import] / [reputation_export] (4.13) e [health] (5.4). serbero_pubkey, in [mostro], è trattato in 5.10.

Ritenzione degli eventi. Quanto tempo Mostro conserva ogni tipo di evento prima che scada. Ometti del tutto il blocco per accettare i valori predefiniti.

[expiration]
order_days = 30        # eventi degli ordini (kind 38383)
rating_days = 90       # storico della reputazione (kind 38384)
dispute_days = 90      # dispute, conservate più a lungo per l'audit (kind 38386)
fee_audit_days = 365   # trasparenza delle commissioni (kind 8383)
dm_days = 30           # messaggi diretti del protocollo v2 (kind 14)

Cauzioni anti-abuso

[anti_abuse_bond] chiede ai taker, ai maker o a entrambi di bloccare una piccola hold invoice Lightning accanto all'operazione. Gli utenti onesti la riavono intatta; un solver può confiscare la cauzione di chi ha agito in malafede, e una quota va alla controparte onesta. Gli utenti la vedono come un "deposito" nell'app, e la documentazione utente la spiega nel capitolo Deposito anti-abuso. Tutte le fasi sono state rilasciate; è disabilitata per default.

[anti_abuse_bond]
enabled = true
amount_pct = 0.01                 # cauzione = max(1% dell'ordine, base_amount_sats)
base_amount_sats = 1000
apply_to = "take"                 # "take" | "make" | "both"
slash_on_waiting_timeout = false  # confisca anche a chi lascia scadere il proprio passaggio
slash_node_share_pct = 0.5        # quota della cauzione confiscata che il nodo trattiene
payout_claim_window_days = 15     # tempo che ha il vincitore per reclamare la sua quota
maker_bond_payment_timeout_seconds = 900
# bond_cltv_delta = 432           # vedi sotto

Leggi il docs/ANTI_ABUSE_BOND.md del progetto prima di abilitarla su un nodo in produzione, e annunciala prima ai tuoi utenti.

Storico del pagatore (sperimentale)

[payer_history] combatte la truffa della triangolazione, in cui un acquirente paga dal conto bancario di un terzo. L'acquirente si impegna con un hash del conto da cui pagherà (declare-payer), il venditore può confrontarlo con il mittente nel suo estratto conto, e Mostro conserva solo un HMAC. Alla v0.20.2 è collegata solo la dichiarazione: il controllo require_declaration e lo storico mostrato ai venditori non sono ancora implementati, e nessun client rilasciato invia declare-payer. Per ora lascialo spento.

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

Escrow Cashu

[cashu] è una modalità sperimentale che gira senza LND e tiene l'escrow in token Cashu. Non è ancora utilizzabile per operare davvero — le azioni di trade dopo la presa vengono ancora rifiutate — e non si può combinare con le cauzioni anti-abuso. Dalla v0.19.3 il maker sceglie la mint per ogni ordine da una lista consentita:

# [cashu]
# enabled = false
# mint_urls = ["https://mint.example.com"]   # [] vuoto = qualsiasi mint con host pubblico
# escrow_locktime_days = 15

La vecchia chiave singola mint_url viene rifiutata: una configurazione che la contiene non si carica.

4.12 Stablecoin e Bitcoin su Altre Reti

Dalla v0.20.2 un nodo può offrire operazioni contro sei codici che non sono valute fiat: stablecoin in dollari e bitcoin su altre reti. I sat Lightning sono sempre un lato dell'operazione; l'altro lato viene pagato on-chain, su Liquid, su Rootstock o sulla rete della stablecoin, direttamente tra i due utenti.

CodiceCos'èQuotato comeImporto dell'ordine in
USDTTether USD1 USDmonete intere
USDCUSD Coin1 USDmonete intere
DOCDollar on Chain (Rootstock)1 USDmonete intere
BTCBitcoin on-chain1 sat = 1 satsat
LBTCL-BTC su Liquid1 sat = 1 satsat
RBTCRBTC su Rootstock1 sat = 1 satsat

Abilitarlo

Ti serve mostrod v0.20.2 o successivo. Due impostazioni lavorano insieme: fiat_currencies_accepted dice quali codici possono usare gli ordini, e il provider pegged dice quali di loro hanno un prezzo di mercato.

[mostro]
# Mantieni le tue valute fiat e aggiungi i nuovi codici, in MAIUSCOLO
fiat_currencies_accepted = ['USD', 'EUR', 'USDT', 'USDC', 'DOC', 'LBTC', 'RBTC']

# Una fonte di prezzo di mercato per il fiat (e quindi per le stablecoin).
# Obbligatoria nella v0.20.2 appena aggiungi una qualsiasi tabella [price.providers.*].
[price.providers.yadio]
enabled = true
url = "https://api.yadio.io"

[price.providers.pegged]
enabled = true
only = ["USDT", "USDC", "DOC", "LBTC", "RBTC"]   # oppure except = ["BTC"]; senza nessuno dei due, tutti e sei

Riavvia Mostro e controlla il log. Se vedi price: the pegged provider quotes ... but fiat_currencies_accepted does not list them, aggiungi i codici mancanti: un codice quotato ma non accettato pubblica un tasso ma rifiuta ogni ordine. Un fiat_currencies_accepted = [] vuoto accetta tutti i codici.

⚠️ Non aggiungere il blocco pegged da solo nella v0.20.2

Qualsiasi tabella [price.providers.*] porta il nodo al motore di prezzi multi-fonte e abbandona il vecchio bitcoin_price_api_url. Nella v0.20.2 una tabella pegged senza una fonte di mercato accanto lascia il nodo senza tassi fiat: tutti gli ordini a prezzo di mercato in USD, EUR e USDT vengono rifiutati. Abilita sempre almeno una fonte di mercato, come nell'esempio sopra. (La prossima versione mantiene automaticamente la vecchia fonte Yadio in quel caso.) Nella v0.20.1 o precedenti, non aggiungere affatto il blocco: il provider lì non esiste.

Solo prezzo fisso. Per accettare un codice senza quotarlo a mercato, elencalo in fiat_currencies_accepted e lascialo fuori da only. Gli utenti dovranno allora impostare un importo fisso di sat. È una scelta sensata per il BTC on-chain, dove le commissioni di rete rendono scomodi i piccoli ordini a prezzo di mercato.

Cosa vedono i tuoi utenti

La Mostro App 2.1.2 e successive mostra questi codici nel selettore di valuta sotto Stablecoin e Bitcoin su altre reti, ma solo quelli che il tuo nodo accetta. Gli importi in BTC, LBTC e RBTC si inseriscono in sat. Il metodo di pagamento indica la rete (USDT (Tron), USDC (Base), DOC (Rootstock), LBTC (Liquid)…), il venditore condivide un indirizzo di ricezione nella chat dell'operazione, e l'acquirente vi incolla l'ID della transazione dopo aver pagato. Mostro non verifica mai né la rete né l'indirizzo. Per ora mostro-cli e Mostrix possono creare solo ordini a prezzo fisso in questi codici.

Le dispute richiedono prove diverse

Informa i tuoi solver prima di abilitarlo. Non c'è nessun estratto conto bancario: la prova è l'ID della transazione incollato nella chat, che il solver controlla in un block explorer di quella rete. Per Liquid l'acquirente deve condividere il link unblinded, perché Liquid nasconde gli importi. I trasferimenti sono irreversibili, un pagamento sulla rete sbagliata può andare perso, e l'acquirente paga la commissione di rete: il venditore deve ricevere l'importo intero. Il venditore dovrebbe rilasciare solo dopo la conferma del trasferimento. La finestra è la stessa del fiat (circa 120 blocchi con i valori predefiniti, vedi 4.5), quindi un trasferimento on-chain a commissione bassa può non rispettarla.

💡 Se una stablecoin perde l'aggancio

Non esiste ancora una protezione automatica dal depeg. Se USDT o USDC si allontana da un dollaro, toglila da only, o aggiungila a except se non usi only (lasciala in fiat_currencies_accepted se vuoi ancora ordini a prezzo fisso) e riavvia.

4.13 Importazione ed esportazione della reputazione

Gli utenti possono portare nel tuo nodo la reputazione guadagnata altrove — sul bot Telegram @lnp2pBot o su un altro nodo Mostro — così chi si trasferisce non riparte da zero. Viaggiano tre dati: il numero di valutazioni ricevute, la valutazione media e la data della prima operazione. Arrivano come attestazione: un piccolo evento Nostr (kind 38388) firmato dalla fonte, indirizzato all'identità dell'utente e valido per 7 giorni. Il tuo nodo li somma alla reputazione dell'utente, e le controparti vedono un'unica cifra unita.

Entrambe le direzioni sono opt-in e spente per default. L'importazione richiede mostrod v0.20.0 o successivo; l'esportazione, v0.20.1 o successivo. Gli utenti hanno bisogno della Mostro App in modalità reputazione: in modalità privacy totale non esiste un'identità che possa portare una reputazione.

Importare da lnp2pBot

lnp2pBot firma le attestazioni con una chiave dedicata. Aggiungila alla tua lista di fiducia:

[reputation_import]
enabled = true
max_lifetime_seconds = 604800   # attestazione più longeva che accetti (7 giorni; al massimo 30)

[[reputation_import.issuers]]
name = "lnp2pbot"               # non rinominare mai una voce che ha già importazioni
keys = ["000004ac730537f1cf7d91f4f584a498a530a0205d35e816ebbaf23aec61e459"]
# npub1qqqqftrnq5mlrnmaj860tp9ynzjnpgpqt567s9hthter4mrpu3vsrta3em

Riavvia Mostro. Il tuo evento info (kind 38385) porta ora un tag reputation_import_issuers, ed è così che l'app sa di poter offrire l'importazione sul tuo nodo. Diversi nodi di comunità si fidano già di questa chiave.

Il bot esporta un account con almeno 10 operazioni completate e 5 valutazioni ricevute che non sia bannato. L'utente parte dall'app (Impostazioni → Rete → Reputazione → Importa reputazione → Ottienila da lnp2pBot), conferma su Telegram che la npub corrisponde e incolla il messaggio che il bot gli invia.

Fidarsi di un altro nodo Mostro

Un nodo che esporta annuncia la sua chiave di firma nel tag reputation_issuer del suo evento info. Leggilo con il comando in 5.4 (cerca quel tag), confermalo con l'operatore e aggiungi una voce per lui:

[[reputation_import.issuers]]
name = "mostro-example"         # un nome locale stabile a tua scelta
keys = ["<that node's reputation_issuer key, npub or hex>"]

Un utente può importare una volta da ciascuna fonte su ciascun nodo, e l'importazione non può essere annullata dall'utente. Le cifre sono un'istantanea: le valutazioni successive sulla fonte non vengono seguite.

Esportare dal tuo nodo

L'esportazione permette ai tuoi utenti di portare la reputazione guadagnata sul tuo nodo in un altro. Viaggiano solo le valutazioni ricevute sul tuo nodo, mai quelle importate. L'utente ha bisogno di 10 operazioni completate e 5 valutazioni ricevute sul tuo nodo, e non deve essere bannato.

Le attestazioni sono firmate con una chiave dedicata, mai con quella del tuo nodo. Generane una e tienila accanto al nsec, nell'ambiente o in <config-dir>/.env:

# Layout Docker Hub; altrimenti usa la tua directory di configurazione
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       # da 1 a 604800 (7 giorni)

Mostro si rifiuta di partire se la variabile manca o non è valida, se contiene la chiave del tuo nodo, o se la sua chiave pubblica è anche nella tua lista [reputation_import]. Una volta in funzione, il tuo evento info porta il tag reputation_issuer: condividi quella chiave con gli operatori che vogliono fidarsi del tuo nodo. Fai il backup della chiave insieme agli altri segreti. Se trapela, chiunque può coniare attestazioni a nome del tuo nodo finché gli altri operatori non la rimuovono e revocano le importazioni.

Revocare le importazioni e ricollegare le esportazioni

Due chiamate RPC di amministrazione (4.7) gestiscono i casi rari. Sono accettate solo da loopback; aggiungi -H 'authorization: Bearer <token>' se hai impostato auth_token. Eseguile da un checkout del repository mostro, che contiene proto/admin.proto.

La chiave di un emittente di fiducia è trapelata. Prima rimuovi la chiave dalla sua voce e riavvia, poi annulla ogni importazione firmata con essa (aggiungi "imported_after": <unix time> per limitarti a quelle recenti):

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

Ogni importazione viene annullata esattamente, le valutazioni ricevute da allora vengono mantenute, e gli utenti possono importare di nuovo con un'attestazione della nuova chiave.

Un utente ha perso l'identità a cui è legata la sua esportazione. La prima esportazione lega l'account a una identità; spostarlo richiede normalmente un'autorizzazione firmata con la vecchia identità, che l'app produce. Se la vecchia identità è persa, puoi spostarlo tu stesso dopo aver verificato 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 utente che ripristina le stesse 12 parole mantiene la stessa identità e non ha bisogno di nulla di tutto questo.

5. Gestione del Tuo Nodo Mostro

5.1 Come funzionano le dispute

Le dispute sono la tua responsabilità operativa più importante.

Quando si verificano le dispute?

Il processo di disputa:

  1. L'utente apre una disputa — Una delle parti clicca "Disputa" nel client
  2. Mostro segna l'ordine — Lo stato cambia in "Disputa", i fondi restano bloccati
  3. L'arbitro prende il caso — Un admin assegnato al tuo nodo indaga
  4. Indagine — Comunica con entrambe le parti, richiede prove
  5. Risoluzione — L'arbitro decide: rilasciare all'acquirente, o rimborsare al venditore. Con le cauzioni anti-abuso abilitate (4.11), l'arbitro può anche confiscare la cauzione di chi ha agito in malafede.

L'arbitro scrive a ciascuna parte su una chat di disputa privata, che la Mostro App mostra sotto Chat → Dispute. Ciascuna parte può anche condividere con l'arbitro la chiave della propria chat dell'operazione, e l'arbitro legge allora quella conversazione nella scheda Observer di Mostrix o in Bosstro. Le parti possono comunque chiudere l'operazione da sole: se il venditore rilascia, o se entrambe concordano un annullamento cooperativo, Mostro chiude da sé la disputa e avvisa l'arbitro.

Se esegui Serbero (5.10), questo avvisa i tuoi arbitri nel momento in cui si apre una disputa e può compiere i primi passi con le parti. Non decide né sposta mai fondi.

⚠️ Importante

Scegli i tuoi arbitri con cura. Hanno il potere di decidere dove vanno i fondi bloccati. Scegli membri fidati e imparziali della comunità. Si raccomandano 2-3 arbitri.

Livelli di permesso dei solver

Un solver può essere registrato in sola lettura o con pieni poteri. Entrambi i livelli possono prendere una disputa e parlare con le parti, ma solo un solver read-write può decidere dove va il denaro.

Registrato comePuòNon può
npub1...:readPrendere una disputa, leggerla, scrivere a entrambe le partiLiquidare o annullare l'ordine
npub1...:read-writeTutto, incluso liquidare e annullare—

Un npub1... nudo senza suffisso diventa read-write per default, e lo stesso vale per la registrazione tramite l'interfaccia RPC. Fai partire un nuovo arbitro con :read mentre impara il processo, poi registralo di nuovo come read-write quando ti fidi del suo giudizio. Un solver read-write può rilevare una disputa che un solver in sola lettura (o Serbero) sta seguendo.

I tuoi arbitri possono lavorare da un terminale con Mostrix (5.2) o da un telefono Android con Bosstro (5.11).

5.2 Mostrix — Il tuo strumento di amministrazione

Mostrix è un client Mostro da terminale (TUI) con due modalità: una modalità utente per operare e una modalità admin per la risoluzione delle dispute — prendere le dispute, parlare con entrambe le parti, liquidare o annullare, confiscare cauzioni e aggiungere solver. Se esegui un nodo Mostro, hai bisogno di Mostrix. Parla con il tuo nodo solo via Nostr, mai tramite l'interfaccia RPC.

Opzione A: Scarica il binario pre-compilato (Raccomandato)

Scarica l'ultima versione per la tua piattaforma da 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 e 5, SO a 64 bit)
wget https://github.com/MostroP2P/mostrix/releases/latest/download/mostrix-aarch64-unknown-linux-musl

# Linux (ARMv7 / Raspberry Pi OS a 32 bit)
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: scarica mostrix-x86_64-pc-windows-msvc.exe dalla pagina delle release

Verifica il download prima di eseguirlo, come spiegato subito sotto.

🔐 Verifica la Release

Verifica sempre il binario prima di eseguirlo. Importa le chiavi dei manutentori una sola volta:

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

Le firme sono file separati chiamati manifest.txt.sig.<manutentore>. Le release recenti portano solo manifest.txt.sig.arkanoider (chiave 2E98 6CA1 C5E7 EA16 35CD 059C 4989 CC74 15A4 3AEC), quindi controlla la pagina della release e scarica quelle effettivamente elencate:

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 ogni firma che hai scaricato
gpg --verify manifest.txt.sig.arkanoider manifest.txt

# Poi confronta l'hash del binario con il manifest
# (le righe del manifest hanno un prefisso artifact-<target>/, qui rimosso)
sed 's#  artifact-[^/]*/#  #' manifest.txt | sha256sum -c --ignore-missing

Una firma valida da una chiave di manutentore di cui ti fidi è sufficiente. Se un wget restituisce 404, quella firma semplicemente non è stata pubblicata per quella release: non trattare un file assente come uno verificato.

Solo quando una firma e l'hash tornano, rendi eseguibile il binario e avvialo:

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

Opzione B: Compila dal codice sorgente

Se preferisci compilare dal codice sorgente o hai bisogno di una piattaforma non disponibile nelle release:

# Installa le dipendenze (Ubuntu/Debian)
sudo apt install -y cmake build-essential pkg-config

# Installa Rust (se non già installato; Mostrix richiede la 1.97 o successiva)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Clona e compila
git clone https://github.com/MostroP2P/mostrix.git
cd mostrix
cargo build --release

# Esegui
./target/release/mostrix

Primo avvio e configurazione

Al primo avvio Mostrix crea ~/.mostrix/ con un database che contiene un nuovo seed di 12 parole e un settings.toml, poi mostra un popup Backup New Keys con le 12 parole. Annotale. Un settings.toml messo accanto al binario ha la precedenza (modalità portatile).

⚠️ Importante: Punta Mostrix al tuo nodo

La configurazione generata punta al nodo pubblico predefinito di Mostro. Passa al tuo nodo: Settings → Select Mostro Instance, poi incolla la npub o l'hex del tuo nodo, oppure modifica mostro_pubkey in ~/.mostrix/settings.toml e riavvia.

Per la modalità admin (risoluzione dispute), le chiavi rilevanti sono:

# ~/.mostrix/settings.toml
mostro_pubkey = "LA_TUA_PUBKEY_MOSTRO"         # hex o npub
nsec_privkey  = "nsec1..."                   # la tua identità di trader, derivata dal seed — non modificarla
admin_privkey = "nsec1..."                   # la chiave di un solver registrato — vedi sotto
relays = ["wss://relay.mostro.network"]
currencies_filter = []                       # vuoto = mostra tutte le valute
user_mode = "admin"                          # oppure Settings → Switch Mode
# trusted_dm_senders = ["npub1..."]          # la npub di Serbero, per vedere i suoi report (5.10)
⚠️ Quale chiave va in admin_privkey?

Mostro accetta le azioni di disputa dalla propria chiave (il nsec_privkey del daemon) e dalle chiavi dei solver registrati. Qualsiasi altra chiave viene rifiutata. Solo la chiave del daemon può aggiungere solver, quindi usala solo per quello e tienila sul server. Per il lavoro quotidiano sulle dispute, registra una chiave di solver — read-write per liquidare o annullare — e metti quella in admin_privkey. Non riusare mai nsec_privkey.

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

L'opzione Settings → Add Dispute Solver di Mostrix fa la stessa cosa, con Sinistra/Destra per scegliere Read o Read-Write (default Read-Write).

La modalità admin in pratica

5.3 mostro-watchdog — Avvisi Telegram per dispute e salute del nodo

mostro-watchdog è un bot Telegram per il tuo team di admin. Osserva il tuo nodo via Nostr e scrive su un gruppo o canale privato:

Opzione A: script di installazione (raccomandato). Scarica l'ultima release, la verifica con manifest.txt e installa in /usr/local/bin:

curl -fsSL https://raw.githubusercontent.com/MostroP2P/mostro-watchdog/main/install.sh | bash
# oppure in un'altra directory:
curl -fsSL https://raw.githubusercontent.com/MostroP2P/mostro-watchdog/main/install.sh | bash -s -- --install-dir ~/.local/bin

Opzione B: download manuale del binario

# Linux x86_64 (Intel/AMD); usa mostro-watchdog-linux-aarch64 su 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

Sulla pagina delle release ci sono anche i binari per macOS e Windows.

Opzione C: compilare dal codice sorgente

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/

Configurazione

Il watchdog tiene il suo stato (disputes.db) accanto a config.toml, quindi dagli una directory tutta sua:

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 = "LA_TUA_PUBKEY_MOSTRO"         # hex o npub

[nostr]
# Relay di bootstrap: il watchdog legge da loro la lista di relay del tuo nodo (NIP-65),
# poi segue i relay che il tuo nodo annuncia.
relays = ["wss://relay.mostro.network", "wss://nos.lol"]

[telegram]
bot_token = "IL_TUO_BOT_TOKEN"          # da @BotFather
chat_id = -1001234567890              # il tuo gruppo o canale admin

[health]
info_silence_threshold = 900          # 3 × publish_mostro_info_interval di Mostro (300 per default)
mostro_health_enabled = true          # richiede Mostro v0.20.0+
event_alert_threshold = 0             # vedi sotto

Per trovare chat_id, aggiungi il bot al gruppo, scrivi un messaggio e apri https://api.telegram.org/bot<TOKEN>/getUpdates.

Il vecchio avviso "event silence" scatta ogni volta che per due ore non arriva nessun evento di disputa, il che sulla maggior parte dei nodi è solo un pomeriggio tranquillo. I controlli info e health rilevano in modo affidabile un nodo fermo, quindi 0 lo disattiva.

La chiave Nostr del watchdog

I dettagli sulla salute, gli avvisi di Serbero, i ping ai solver e il heartbeat del watchdog stesso richiedono una chiave propria, passata solo tramite l'ambiente:

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

Fai il backup di quel file. All'avvio il watchdog registra la sua chiave pubblica. Mettila nel settings.toml di Mostro e riavvia Mostro, così la tua liquidità, i fallimenti dei pagamenti e le scadenze HTLC sono cifrati per il solo watchdog:

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

Questo aggiunge al tuo evento di salute un tag pubblico p che collega il tuo nodo alla chiave del watchdog. Senza, il watchdog avvisa comunque sullo stato pubblico.

Eseguirlo come servizio

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

Opzionale: Serbero e avvisi ai solver

Aggiungi una sezione vuota per ciascuno che vuoi. Entrambi usano la chiave qui sopra:

[serbero]                 # i passi di Serbero sul messaggio di ogni disputa
[solver_notifications]    # ping privati ai solver

Per Serbero, aggiungi anche la chiave pubblica hex del watchdog al config.toml di Serbero come osservatore — mai come solver — e riavvia Serbero. Gli osservatori ricevono una riga per passo, mai ciò che hanno scritto le parti. Il watchdog trova Serbero da solo tramite il serbero_pubkey del tuo nodo (5.10).

[[observers]]
pubkey = "WATCHDOG_PUBKEY_HEX"

Per i ping ai solver, ogni solver invia /link al bot in una chat privata e inserisce il codice in Mostrix 0.3.6 o successivo, sotto Settings → Link Watchdog. Il bot risponde ai comandi solo nelle chat private: /version, /link, /unlink, /status.

💡 Controlla il watchdog

Un canale silenzioso non prova che il watchdog sia vivo. Puoi eseguirne un secondo su un'altra macchina, ciascuno con la propria WATCHDOG_NOSTR_PRIVATE_KEY e la chiave pubblica dell'altro in [health].peer_watchdogs. Gli avvisi di salute possono anche andare a una chat dedicata con [health].alerts_chat_id. Il config.example.toml del progetto documenta ogni opzione.

5.4 Monitoraggio e salute del nodo

Il tuo nodo deve essere in funzione 24/7.

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

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

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

Essere in funzione non significa funzionare

Nell'ottobre 2026 l'LND di un nodo in produzione ha smesso di seguire la catena per circa 21 ore. Mostro continuava a girare e ad accettare operazioni, ma ogni pagamento a un acquirente falliva. Un controllo del processo, della porta o un robot di uptime sarebbero rimasti verdi per tutto il tempo.

Dalla v0.20.0 Mostro lo controlla da sé. Ogni minuto pubblica un evento di salute firmato (kind 38389) con uno stato generale (ok, degraded o down), uno stato per ogni controllo (lnd_sync, payouts, relays, database) e l'altezza di blocco di LND. È attivo per default; questo blocco mostra solo i valori predefiniti:

[health]
enabled = true                  # pubblica l'evento di salute (kind 38389)
interval = 60                   # secondi tra una pubblicazione e l'altra, da 30 a 3600
watchdog_pubkey = ""            # la chiave del tuo watchdog: le metriche dettagliate sono cifrate per lei (5.3)
lnd_unsynced_fail_after = 600   # deve essere maggiore di 60
auto_maintenance_on_lnd_unsynced = true
lnd_resynced_clear_after = 300

Quando LND smette di essere sincronizzato, Mostro protegge da solo i tuoi utenti:

Il log racconta la storia: LND reports synced_to_chain = false ...; outgoing payments wait after 60s, poi maintenance mode ON (reason lnd_unsynced), e più tardi LND is synced to chain again e maintenance mode OFF. Controlla LND con lncli getinfo (synced_to_chain, block_height). Imposta auto_maintenance_on_lnd_unsynced = false per rinunciare alla manutenzione automatica.

Mostro sa solo ciò che gli dice il suo LND, e un nodo bloccato su una catena obsoleta non sempre se ne accorge. Per questo i due lettori qui sotto confrontano la sua altezza di blocco con gli explorer pubblici:

La pagina di stato pubblica

La pagina (Semáforo) legge gli eventi di salute direttamente dai relay e li verifica nel browser del visitatore, senza backend. Ogni nodo riceve un colore:

ColoreQuando
🟢 OperativoStato ok, un evento recente, e LND meno di 3 blocchi indietro rispetto agli explorer
🟡 DegradatoStato degraded, modalità manutenzione, o nessuna altezza di blocco indipendente con cui confrontarsi
🔴 GiùStato down, LND 3 o più blocchi indietro, o nessun evento valido di recente ("Not reporting")
⚪ Non monitoratoElencato, ma non ci si aspetta ancora che pubblichi

Sotto ogni nodo, 90 barre giornaliere e una cifra di uptime vengono da campioni presi ogni 10 minuti.

Farsi elencare. Vengono mostrati solo nodi selezionati, perché chiunque può firmare un evento sempre verde:

  1. Il tuo nodo è elencato come comunità su questo sito.
  2. Esegue Mostro v0.20.0 o successivo con l'evento di salute attivo, e pubblica su almeno uno tra wss://relay.mostro.network, wss://mostro-p2p.tech o wss://relay.shadowbip.com.
  3. Apri una issue o una pull request su MostroP2P/semaforo per aggiungerlo a trusted.json con la sua pubkey hex, nome, regione e rete. Il tuo avatar viene copiato dalla foto del tuo profilo Nostr.

Controllare il tuo nodo dall'esterno

Il tuo nodo ripubblica un evento info (kind 38385) che lo descrive: commissioni, valute, versione del protocollo, flag di manutenzione, impostazioni delle cauzioni, chiavi di Serbero e della reputazione. Leggere questo e l'evento di salute da un relay è il modo più rapido di confermare che il mondo esterno vede quello che credi.

cargo install nostreq nostcat
# Evento info
nostreq --kinds 38385 --limit 1 --authors LA_TUA_MOSTRO_PUBKEY_HEX \
  | nostcat --stream wss://relay.mostro.network | jq
# Evento di salute: stato, controlli, altezza di blocco di LND
nostreq --kinds 38389 --limit 1 --authors LA_TUA_MOSTRO_PUBKEY_HEX \
  | nostcat --stream wss://relay.mostro.network | jq '.tags'
💡 I controlli sull'host servono ancora

Un ping all'host (UptimeRobot o simili) ti dice ancora quando il VPS stesso è irraggiungibile. Non può dirti se Mostro sta pagando gli acquirenti; l'evento di salute sì.

5.5 Aggiornare Mostro

Aggiornare sostituisce il binario mostrod e nient'altro: settings.toml e mostro.db restano dove sono. Le migrazioni del database si applicano da sole all'avvio della nuova versione, quindi non ci sono passi aggiuntivi.

Prima di aggiornare

  1. Leggi le note di rilascio della versione a cui passi. Il tuo settings.toml non viene mai sovrascritto: confrontalo con il nuovo settings.tpl.toml. La maggior parte delle nuove funzioni resta spenta finché non le aggiungi, ma un blocco mancante prende i valori predefiniti, e alcuni sono attivi (l'evento di salute di 5.4, per esempio).
  2. Fai un backup del database con i comandi di 5.6. Ti serve per tornare indietro.
⚠️ Se arrivi dalla v0.18.x

Controlla questi punti prima di avviare la nuova versione, o potrebbe rifiutarsi di partire:

  • Elimina qualsiasi riga transport = "gift-wrap" (4.8). Gli utenti con vecchi client protocollo v1 devono aggiornare.
  • escrow_deadline_margin_blocks deve essere almeno 18 e inferiore a hold_invoice_cltv_delta (4.9).
  • Sotto [cashu], mint_url è diventato mint_urls = [...] (4.11).
  • Con le cauzioni anti-abuso attive e hold_invoice_cltv_delta pari o superiore a 288, imposta bond_cltv_delta esplicitamente (4.11).
  • Dalla v0.20.0 l'evento di salute viene pubblicato per default, e Mostro può entrare da solo in manutenzione quando LND non è sincronizzato (5.4).

Docker Hub (docker run)

export MOSTRO_TAG=v0.20.2
# Scarica prima: il nodo resta attivo durante il download
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 gli stessi flag dell'installazione (togli --add-host se LND è su un altro server). Se non li ricordi, controlla docker inspect mostro prima di rimuovere il container.

⚠️ docker restart non è un aggiornamento

docker restart riavvia lo stesso container, con l'immagine da cui è stato creato. Per eseguire una nuova versione il container va ricreato: docker rm + docker run, oppure docker compose up -d dopo aver cambiato il tag.

Docker Hub (Docker Compose)

export MOSTRO_TAG=v0.20.2
COMPOSE=~/mostro-docker/compose.yml
# Punta la riga image al nuovo tag e controllala
sed -i "s|image: mostrop2p/mostro:.*|image: mostrop2p/mostro:$MOSTRO_TAG|" $COMPOSE
grep image: $COMPOSE
docker compose -f $COMPOSE pull
# Ricrea il container perché l'immagine è cambiata
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

Verificare la nuova versione

# 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

Cerca gli stessi messaggi di avvio della prima esecuzione (Passo 11 dell'Opzione A).

Tornare indietro

Se la nuova versione dà problemi, torna al tag precedente. La nuova versione potrebbe aver già migrato il database, e un mostrod più vecchio può rifiutarsi di avviarsi con esso, quindi ripristina il backup fatto prima di aggiornare:

docker stop mostro
docker rm mostro
# sostituisci YYYYMMDD con la data del backup fatto prima di aggiornare
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
# poi avvia il tag precedente: stesso comando docker run,
# oppure rimetti il vecchio tag in compose.yml ed esegui docker compose up -d

Docker Build e nativo funzionano allo stesso modo: torna al tag precedente, ricompila e ripristina il database prima di avviare.

⚠️ Non cambiare nodo Lightning nello stesso momento

Aggiornare Mostro è sicuro in qualsiasi momento. Puntarlo a un nodo Lightning diverso non lo è: drena prima l'escrow, vedi 5.8.

5.6 Backup

File critici da salvare: settings.toml, il file .env se ci tieni il tuo nsec (vedi 4.1) o la chiave di esportazione della reputazione (4.13), e mostro.db (storico ordini, reputazione). Se abiliti lo storico del pagatore (4.11), tieni i backup del database separati dal nsec: lo storico è indicizzato con esso.

⚠️ Non copiare un database attivo con cp

SQLite lavora in modalità WAL, quindi le scritture recenti stanno in mostro.db-wal finché non vengono consolidate. Copiare solo mostro.db mentre Mostro è in esecuzione può produrre un backup a cui mancano le operazioni più recenti. Usa il comando di backup nativo di SQLite, che è sicuro su un database attivo e scrive un unico file coerente.

# Backup manuale — 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

# Backup manuale — Docker Build (Opzione 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

# Backup manuale — 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

Backup giornaliero automatico (aggiungi al crontab con crontab -e):

# Docker Hub (Opzione 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 (Opzione 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 (Opzione 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
⚠️ Critico

La tua nsec_privkey in settings.toml È l'identità del tuo nodo. Se la perdi, perdi la tua reputazione e tutti gli utenti devono riconnettersi a una nuova identità. Conserva una copia offline.

Se gestisci il tuo LND

I backup di Mostro non coprono il tuo nodo Lightning. I fondi nei tuoi canali dipendono da due backup di LND:

Non fare mai il backup né il ripristino di channel.db per recuperare i canali: una copia obsoleta fa trasmettere al tuo nodo stati vecchi, e i peer possono prendersi tutti i fondi di quei canali. I sistemi nodo-in-a-box e Voltage hanno funzioni di backup proprie; attivale. La documentazione di LND tratta il recupero in dettaglio (recovery planning).

5.7 Revisione dell'attività delle operazioni

# Contare tutti gli ordini
sqlite3 /percorso/di/mostro.db "SELECT COUNT(*) FROM orders;"

# Operazioni recenti riuscite
sqlite3 /percorso/di/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;"

# Ordini in attesa
sqlite3 /percorso/di/mostro.db "SELECT id, fiat_code, fiat_amount, status, created_at FROM orders WHERE status = 'pending';"

# Ricavi da commissioni: orders.fee memorizza la metà di ciascuna parte, quindi la commissione lorda del nodo è fee*2 e la dev fee viene sottratta da essa
sqlite3 /percorso/di/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 Modalità Manutenzione e Cambio di Nodo Lightning

Le hold invoice, le cauzioni e i pagamenti in volo appartengono al nodo Lightning che li ha creati. Puntare Mostro a un altro nodo mentre qualcosa di tutto questo è aperto lascerebbe quelle operazioni in sospeso, quindi il daemon si rifiuta di partire quando vede una nuova identità LND con escrow ancora legato alla precedente:

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

La modalità manutenzione è il modo per drenare prima. Mentre è attiva, nuovi ordini e prese vengono rifiutati e le operazioni aperte continuano a funzionare, così l'escrow può liquidarsi. Richiede l'interfaccia RPC abilitata (vedi 4.7), e la chiamata è accettata solo da loopback: eseguila sull'host del nodo, oppure tramite ssh -N -L 50051:127.0.0.1:50051 user@node.

Mostro può anche entrare da solo in manutenzione, con il motivo lnd_unsynced, quando LND perde la sincronizzazione (5.4). Se attivi la manutenzione mentre quella è in corso, diventa tua e il daemon non la toglierà; non puoi usare lnd_unsynced come tuo motivo.

  1. Annuncia la finestra ai tuoi utenti con ampio preavviso.
  2. Attiva la modalità manutenzione: mostro-cli admsetmaintenance -e true -r "LN node migration".
  3. Interroga mostro-cli admmaintenancestatus finché non riporta drained = true. Gli ordini in attesa scadono da soli; per accorciare il drenaggio puoi annullarne uno con mostro-cli admcancelpending -o <order-id>, che libera subito la cauzione del creatore. Annuncialo prima, è l'ordine dell'utente. Chiudi le dispute di lunga durata come sempre.
  4. Tieni online il nodo vecchio per tutto il tempo. Deve ancora completare i pagamenti in volo.
  5. Ferma Mostro e fai il backup di mostro.db.
  6. Punta [lightning] al nodo nuovo e lascia allow_node_change = false.
  7. Avvia Mostro. Registra la nuova pubkey. Disattiva la modalità manutenzione e prova con un ordine.
  8. Solo adesso dismetti il nodo vecchio.
⚠️ allow_node_change

Mettilo a true solo per il disaster recovery, quando il nodo vecchio è perso definitivamente. Lascia consapevolmente irrisolte le operazioni coinvolte. Spostare lo stesso nodo su un altro host non è un cambio di nodo e non richiede nulla di tutto questo.

5.9 Comandi da Operatore con mostro-cli

Mostrix è il modo comodo per lavorare le dispute, e mostro-cli copre le basi da shell, più alcuni comandi da operatore che Mostrix non ha. I comandi di disputa sono firmati con una chiave Nostr che passi come ADMIN_NSEC, e deve essere quella del daemon stesso o di un solver registrato. La CLI non legge alcun file di configurazione: imposta il tuo nodo e i relay nell'ambiente, e metti i flag globali prima del sottocomando.

# Lavoro sulle dispute (via Nostr)
export MOSTRO_PUBKEY=npub1...            # il tuo nodo
export RELAYS=wss://relay.mostro.network
export ADMIN_NSEC=nsec1...
mostro-cli listdisputes
mostro-cli admtakedispute -d <dispute-id>     # stampa le pubkey di acquirente e venditore
mostro-cli getadmindm -s 120
mostro-cli admsenddm -p <party-pubkey> -m "messaggio a una parte"
mostro-cli admsettle -o <order-id> [--slashseller] [--slashbuyer]   # rilascia all'acquirente
mostro-cli admcancel -o <order-id> [--slashseller] [--slashbuyer]   # rimborsa il venditore

# Registra un arbitro, eventualmente in sola lettura
mostro-cli admaddsolver -n npub1...:read

I flag di confisca contano solo con le cauzioni anti-abuso (4.11). Nota l'ortografia: --slashseller, non --slash-seller. admsenddm invia un messaggio diretto dalla chiave admin; non è la chat per disputa che usano la Mostro App, Mostrix e Bosstro, quindi per parlare con le parti preferisci quei client.

Un altro gruppo di comandi passa dal gRPC di amministrazione invece che da Nostr, quindi richiedono l'interfaccia RPC abilitata (vedi 4.7) anziché ADMIN_NSEC. MOSTRO_RPC_URL vale per default http://127.0.0.1:50051, e MOSTRO_RPC_TOKEN serve solo se hai impostato auth_token.

export MOSTRO_RPC_URL=http://127.0.0.1:50051
export MOSTRO_RPC_TOKEN=il-tuo-token-auth

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

admcancelpending vale la pena conoscerlo anche fuori da una migrazione. Annulla un ordine ancora in attesa o in attesa di una cauzione, avvisa il maker e libera tutte le sue cauzioni in un colpo. Usalo per un ordine chiaramente abbandonato o quotato male, e avvisa prima il maker: è il suo ordine, e questa non è una risoluzione di disputa.

mostro-cli non ha ancora comandi per l'importazione e l'esportazione della reputazione, lo storico del pagatore o l'evento di salute: usa grpcurl per le RPC di reputazione (4.13) e i comandi in 5.4 per l'evento di salute. Installalo con cargo install mostro-cli (Rust 1.97 o successivo) oppure prendi un binario dalle sue release; esegui mostro-cli <command> --help per ogni flag.

5.10 Serbero — Assistente per le dispute

Serbero è un assistente opzionale per le dispute del tuo nodo. Lo esegui accanto a Mostro, con una chiave Nostr tutta sua. Fa due lavori:

Serbero non sposta mai fondi e non decide mai una disputa. Mostro lo registra come solver in sola lettura, quindi non può liquidare né annullare, e qualsiasi solver read-write può rilevare una disputa da lui in qualsiasi momento. Se Serbero è fermo, Mostro e i tuoi solver lavorano esattamente come prima. Tieni almeno un solver umano read-write.

Installazione

Ogni release ha binari per Linux (x86_64, aarch64) e macOS (Apple silicon), ciascuno con un file SHA-256. I nomi dei file portano la versione:

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 su 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 installato funziona anche cargo install serbero --locked. Un'immagine Docker (ghcr.io/mostrop2p/serbero) e un file compose sono descritti nel README del progetto.

Configurazione

cp config.sample.toml config.toml
nano config.toml
[serbero]
private_key_env = "SERBERO_PRIVATE_KEY"   # indica il nome del segreto; la chiave non va mai in questo file
db_path = "serbero.db"

[mostro]
pubkey = "LA_TUA_PUBKEY_MOSTRO_HEX"
relays = ["wss://relay.mostro.network", "wss://nos.lol"]   # i relay su cui pubblica il tuo nodo

# Una voce per ogni solver umano: la pubkey hex della chiave che usa il suo client
# (Mostrix: admin_privkey). Non elencare mai la chiave di Serbero.
[[solvers]]
pubkey = "SOLVER_PUBKEY_HEX"
permission = "write"

[notify]
renotify_after = "15m"

[mediation]
enabled = false

Eseguirlo come servizio

Il progetto include un'unità systemd rinforzata. Scaricala da main: la copia dentro l'archivio v0.2.5 richiede systemd 251 e non parte su 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        # annota la npub che registra all'avvio

Fai il backup offline di /etc/serbero/credentials/serbero_private_key. È l'identità di Serbero: se la perdi devi registrare una nuova npub.

Registrarlo sul tuo nodo

Mostro v0.19.1 o successivo registra Serbero per te. Aggiungi la sua npub al blocco [mostro] del tuo settings.toml e riavvia Mostro:

[mostro]
serbero_pubkey = "npub1..."   # la chiave di Serbero, npub o hex

All'avvio Mostro registra quella chiave come solver in sola lettura e la annuncia nel suo evento info. Quell'annuncio è il modo in cui la Mostro App etichetta i messaggi di Serbero e in cui mostro-watchdog lo trova. Il log lo conferma: Serbero npub1... configured: registered as a read-only solver.

⚠️ Non aggiungere Serbero con admaddsolver

Una npub nuda aggiunta con admaddsolver diventa read-write (5.1), e Mostro si rifiuta allora di partire con REFUSING TO START: serbero_pubkey ... is a solver with write permission. Rifiuta anche una chiave che appartiene a un utente che non è un solver, e la chiave del tuo nodo. Dai a Serbero una chiave tutta sua e lascia che serbero_pubkey la registri.

I tuoi solver leggono Serbero in Mostrix

Mostrix 0.3.5 o successivo mostra i messaggi di Serbero in un pannello SERBERO per ogni disputa, ma solo da mittenti di cui il solver si fida. Nel ~/.mostrix/settings.toml di ogni solver:

trusted_dm_senders = ["npub1..."]   # la npub di Serbero

La pubkey dell'admin_privkey del solver deve essere esattamente quella di una voce [[solvers]], e Mostrix deve leggere almeno uno dei relay di Serbero. Per rilevare un caso, premi Ctrl+T su un passaggio di consegne; richiede il permesso read-write, e Serbero smette subito di scrivere. Bosstro (5.11) non mostra ancora i riepiloghi di Serbero.

Attivare la mediazione (pilota)

La mediazione parte spenta. Quando è attiva, Serbero prende ogni nuova disputa e si presenta a entrambe le parti come assistente automatico, nella loro lingua (inglese, spagnolo o portoghese), con una breve domanda alla volta. Quando entrambe hanno risposto, dà loro 30 minuti per sistemare da sole l'operazione, poi passa il caso ai tuoi solver. Non dice mai a nessuno di rilasciare o annullare.

Per leggere le risposte, Serbero interroga un modello giudice (Jev di TypeSafe) sul tuo account a pagamento. Il giudice riceve i ruoli dell'operazione, l'importo, la valuta e il metodo di pagamento, e il testo dei messaggi — mai le chiavi pubbliche. Chiedi al provider zero conservazione dei dati, e avvisa i tuoi utenti che i messaggi di disputa sono elaborati da un servizio automatico. Il README spiega la chiave API e la tabella delle soglie; imposta enabled = true sotto [mediation] e riavvia, e il log dice mediation ready oppure perché no.

I messaggi delle parti sono eventi kind 14: usa più di un relay, e solo relay che li conservano, altrimenti i messaggi inviati mentre Serbero è offline vanno persi. Per pubblicare l'avanzamento di Serbero sul Telegram del tuo team, registra mostro-watchdog come osservatore (5.3). Fai il backup di serbero.db in modo privato: contiene le conversazioni delle dispute.

5.11 Bosstro — Risolvere le dispute dal telefono

Bosstro è l'app Android per i solver delle dispute. Porta su un telefono il lato admin di Mostrix: un solver vede le dispute in attesa del tuo nodo, ne prende una, parla con l'acquirente e il venditore (immagini e PDF inclusi), legge la chat privata delle parti quando una di loro ne condivide la chiave e, con permesso read-write, paga l'acquirente o rimborsa il venditore, con l'opzione cauzione quando il tuo nodo ne ha.

È uno strumento per i tuoi solver, non per operare, e non detiene mai la chiave del tuo nodo. La registrazione dei solver avviene ancora da Mostrix o da mostro-cli (5.2).

Installazione e verifica

Android 7.0 o successivo. Scarica l'APK da GitHub Releases: arm64-v8a per quasi ogni telefono, armeabi-v7a per uno vecchio a 32 bit. Verificalo con il file di checksum della release:

sha256sum -c SHA256SUMS.txt --ignore-missing

Il checksum prova solo che il download è completo. Il certificato di firma prova chi l'ha compilato, e Android rifiuta un aggiornamento firmato con qualsiasi altra chiave. Confrontalo 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

Aggiungere un solver

  1. Il solver apre Bosstro, tocca Create new account (oppure Log in con un nsec di solver esistente) e ti invia la npub. Quella chiave non deve servire a nient'altro — mai la chiave di un'app di trading, o i due ruoli risultano collegati in pubblico.
  2. La registri tu, in sola lettura per cominciare (5.1):
    ADMIN_NSEC=nsec1... mostro-cli admaddsolver -n npub1solver...:read
  3. Il solver sceglie il tuo nodo in Bosstro: Mostro, una comunità dalla lista, oppure la tua pubkey e i tuoi relay. Bosstro capisce dalle risposte del tuo nodo se la chiave è un solver e con quale permesso.
⚠️ Limiti attuali

Bosstro parla solo il protocollo v2 (4.8). La versione 0.1 non mostra i riepiloghi di consegna di Serbero e non ha ancora notifiche push, quindi i solver che lavorano con Serbero hanno ancora bisogno di Mostrix per quelli. Un solver read-write può rilevare una disputa da Serbero in Bosstro.

6. Analisi dei Costi

Costi operativi mensili

VoceCosto mensileNote
VPS (server)$10–24Dipende dal provider e dalle specifiche
Nome di dominio (opzionale)$1–2Per un sito web/identità
Commissioni on-chain canali LightningVariabileApertura/chiusura canali
Totale mensile$11–26Esclusa liquidità Lightning

Costi una tantum / di capitale

VoceCostoNote
Liquidità Lightning0,01–1,0+ BTCBloccata nei canali; recuperata alla chiusura
Hardware del nodo (se self-hosted)$0–600Gratis se usi VPS; $300-600 per Start9/Umbrel
Tempo di configurazione4–16 oreA seconda del livello di esperienza

Potenziale di entrate

Volume mensileCommissione (0,6%)Commissione dev (30%)Il tuo reddito netto
$1.000~$6~$1,80~$4,20
$10.000~$60~$18~$42
$50.000~$300~$90~$210
$100.000~$600~$180~$420
📝 Realtà

La maggior parte dei nodi nuovi impiega mesi per costruire volume di operazioni. Non aspettarti profitti immediati. Il vero valore spesso viene dal fornire un servizio alla tua comunità, con le commissioni come bonus.

Impegno di tempo

AttivitàFrequenzaTempo
Monitoraggio (controllare log, stato)Giornaliero5–10 min
Risoluzione disputeAl bisogno15–60 min per disputa
AggiornamentiMensile15–30 min
Gestione liquiditàSettimanale15–30 min
Stima settimanale totale1–3 ore

7. Domande Frequenti

Devo essere uno sviluppatore per eseguire un nodo Mostro?

No, ma devi sentirti a tuo agio con le operazioni base da riga di comando (digitare comandi, modificare file di testo). Il percorso Docker (Opzione A) è progettato per essere accessibile.

Posso eseguire Mostro su un Raspberry Pi?

Molte persone eseguono LND su un Raspberry Pi 4 o 5 con un SSD, tramite Start9, Umbrel o RaspiBlitz, e il pacchetto Mostro di StartOS può girare accanto. Per un nodo da cui dipende la tua comunità, un VPS è più affidabile di una connessione e di un'alimentazione domestiche. Una via di mezzo comune è LND a casa e Mostro su un VPS, collegati tramite VPN (vedi 2.2).

Posso usare Core Lightning (CLN) invece di LND?

No. Mostro attualmente supporta solo LND, perché dipende dall'implementazione specifica delle hold invoice di LND. Il supporto per altre implementazioni potrebbe arrivare in futuro.

Come si connettono gli utenti al mio Mostro?

Gli utenti hanno bisogno di un client Mostro — la Mostro App per Android, iOS, desktop e web, oppure mostro-cli o Mostrix — e della chiave pubblica del tuo Mostro (npub). Nell'app vanno su Impostazioni → Rete → Nodo Mostro → Aggiungi il tuo nodo e incollano la tua npub; i nodi elencati su questo sito vi compaiono già. Il client comunica attraverso i relay Nostr. Non serve una connessione diretta.

Il mio nodo può ancora servire i vecchi client (protocollo v1)?

No. Dalla v0.19.0 Mostro parla solo il protocollo v2 (4.8). Gli utenti con un vecchio client devono passare alla Mostro App o a un Mostrix o mostro-cli attuale.

I miei utenti possono scambiare USDT, Liquid o Rootstock invece del fiat?

Sì, dalla v0.20.2: USDT, USDC, DOC, BTC on-chain, LBTC e RBTC. Li abiliti uno per uno, e i tuoi solver devono sapere come verificare quei trasferimenti. Vedi 4.12.

Gli utenti possono portare la loro reputazione da lnp2pBot o da un altro Mostro?

Sì, se ti fidi della fonte. Attiva l'importazione della reputazione e aggiungi la chiave di lnp2pBot, o quella di un nodo Mostro di cui ti fidi (4.13). Puoi anche lasciare che i tuoi utenti esportino la reputazione guadagnata sul tuo nodo.

Posso eseguire più istanze di Mostro?

Sì, ma ognuna ha bisogno della propria coppia di chiavi Nostr, nodo LND (o almeno canali/liquidità separati), e configurazione.

È legale?

Dipende molto dalla tua giurisdizione. Mostro è software per il trading peer-to-peer. In alcune giurisdizioni, operare un exchange P2P può richiedere licenze. Verifica le normative locali e chiedi consulenza legale.

Quanta banda usa Mostro?

Pochissima — principalmente piccoli eventi Nostr. Qualche GB al mese è tipico anche con volumi moderati.

Cosa succede se il mio nodo va offline?

Gli ordini in attesa alla fine scadono. Le operazioni attive con fondi bloccati continuano quando torni online. Se sei offline troppo a lungo, gli utenti potrebbero perdere fiducia. Dalla v0.18.3 esiste anche una scadenza per l'escrow: se il nodo resta giù abbastanza a lungo perché la hold invoice si avvicini al suo orizzonte CLTV, LND la annulla e il venditore viene rimborsato automaticamente. Se è il tuo LND a perdere la sincronizzazione mentre Mostro continua a girare, i pagamenti attendono invece di fallire e, dopo 10 minuti, il nodo entra da solo in manutenzione finché LND non si riprende (5.4).

Posso cambiare la mia chiave Nostr in seguito?

Puoi, ma perderai l'identità e la reputazione del tuo nodo. Gli utenti lo vedranno come un nuovo Mostro. Tratta la tua chiave come la tua identità di marca.

Posso perdere soldi eseguendo un nodo Mostro?

Sì, è possibile: i fondi dei canali Lightning potrebbero essere a rischio per bug (raro); la chiusura forzata dei canali durante periodi di commissioni alte può essere costosa; i costi del VPS sono continui.

La liquidità Lightning è "a rischio"?

La tua liquidità Lightning è tua. Non è a rischio da parte di Mostro stesso — le hold invoice sono blocchi temporanei. Tuttavia, si applicano i rischi standard di Lightning Network (chiusure forzate, canali bloccati, bug).

Quando raggiungerò il pareggio?

Dipende dai tuoi costi e dal volume di operazioni. Con $20/mese di costi e 0,6% di commissione, hai bisogno di ~$5.000/mese in operazioni per coprire i costi (prima della commissione di sviluppo). La maggior parte delle comunità impiega 3–6 mesi per costruire un volume significativo.

Posso spostare Mostro su un altro nodo Lightning?

Sì, ma non modificando la configurazione e riavviando. L'escrow è legato al nodo che l'ha creato, quindi prima lo si drena in modalità manutenzione, e il daemon si rifiuta di partire se salti questo passaggio. Spostare lo stesso nodo su un altro host non è un cambio di nodo e non richiede nulla di particolare. Vedi 5.8.

8. Considerazioni di Sicurezza

⚠️ Avviso software in fase iniziale

Mostro è in una fase iniziale di sviluppo. Sebbene il team lavori duramente per garantire l'affidabilità, potrebbero esserci bug non scoperti — inclusi bug di sicurezza che potrebbero risultare in perdita di fondi. Gli sviluppatori non sono responsabili di alcuna perdita di denaro dovuta a bug del software.

Mostro è open-source e il suo codice è aperto a verifiche. Incoraggiamo le comunità a promuovere e finanziare audit di sicurezza indipendenti.

Detto questo, il meccanismo centrale di custodia tramite hold invoice di Lightning è stato testato in battaglia dal 2021, quando @lnp2pBot ha implementato per primo questo tipo di custodia. Migliaia di operazioni sono state completate con successo.

Tieni la Chiave del Tuo Nodo Fuori Portata

La tua nsec_privkey è l'identità del tuo nodo, e chiunque la possieda può impersonare il tuo Mostro. Preferisci fornirla tramite la variabile d'ambiente MOSTRO_NSEC_PRIVKEY o un file .env con chmod 600 invece di lasciarla in settings.toml (vedi 4.1). Non portarla nemmeno su un laptop per gestire le dispute: registra una chiave di solver separata per quello (vedi 5.2).

Operare sotto regimi autoritari

Se operi in un paese con un governo autoritario, la privacy non è opzionale — è un requisito di sicurezza.

  1. Esegui il tuo nodo Mostro dietro Tor e/o una VPN. Questo nasconde l'IP del tuo server dai relay Nostr.
  2. Se Tor/VPN non è possibile (comune nei paesi in via di sviluppo con internet lento), pubblica eventi solo su relay che possiedi o di cui ti fidi.
  3. Fai molta attenzione a quali relay usi. In futuro, i governi potrebbero creare relay Nostr specificamente per raccogliere indirizzi IP.
  4. Considera anche la privacy del tuo nodo Lightning. Eseguire LND dietro Tor è possibile e raccomandato in ambienti sensibili. Il tuo evento info pubblica la pubkey di LND e gli indirizzi che annuncia, quindi fai annunciare a LND solo indirizzi Tor.
  5. Sappi cosa pubblica il tuo nodo. L'evento di salute (5.4) è pubblico: stato, altezza di blocco e rete di LND, versione di Mostro. Impostare un watchdog_pubkey aggiunge un tag che collega il tuo nodo a quella chiave. Disattivalo con [health] enabled = false se ti importa più di questo che del monitoraggio.
  6. Le variabili proxy non bastano. Le ricerche di indirizzi Lightning ignorano deliberatamente HTTP_PROXY/HTTPS_PROXY. Per nascondere l'IP del server, instrada l'intera macchina attraverso Tor o una VPN.
💡 Consiglio

La bellezza del fatto che Mostro sia decentralizzato è che anche se un nodo viene spento, gli altri continuano a funzionare. Ma la prevenzione è sempre meglio del recupero. Prendi la privacy sul serio fin dal primo giorno.

9. Risoluzione dei Problemi

Mostro non si avvia

dev_fee_percentage (0.05) is below minimum (0.1)

Imposta dev_fee_percentage ad almeno 0.10 in settings.toml.

File di configurazione o database non trovato

Assicurati che il flag -d punti alla directory contenente settings.toml. Per Docker Hub: verifica che ~/mostro-config/settings.toml esista.

Mostro termina all'avvio con Ln node error

REFUSING TO START: Lightning node changed

Mostro punta a un'identità LND diversa mentre c'è ancora escrow aperto sulla precedente. Ricollega il nodo vecchio e drenalo prima di cambiare. Vedi 5.8.

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

Elimina la riga transport da settings.toml. Vedi 4.8.

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

Imposta il margine tra 18 e hold_invoice_cltv_delta; il 24 del template con 144 va bene. Vedi 4.9.

unknown field mint_url

In [cashu], rinominala in mint_urls = ["..."]. Vedi 4.11.

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

Imposta bond_cltv_delta esplicitamente entro quei limiti. Nella v0.20.2, le cauzioni più un hold_invoice_cltv_delta pari o superiore a 288 incappano in questo con il valore predefinito. Vedi 4.11.

REFUSING TO START: serbero_pubkey ...

La chiave di Serbero è già un solver read-write, appartiene a un utente, o è la chiave del tuo nodo. Dai a Serbero una chiave tutta sua. Vedi 5.10.

Le impostazioni di reputazione bloccano l'avvio

I nomi degli emittenti devono essere unici e ogni chiave valida ed elencata una sola volta; la chiave di un emittente non deve mai passare a un altro nome una volta che ha importazioni. Con l'esportazione attiva, MOSTRO_REPUTATION_ISSUER_SK deve essere impostata, valida, diversa dalla chiave del tuo nodo e non presente nella tua lista di importazione. Vedi 4.13.

I client non vedono i miei ordini o non riescono a scrivere al mio nodo

Il tuo nodo parla solo il protocollo v2. Un utente con un vecchio client che parla solo il protocollo v1 non riceve risposta e deve aggiornare (4.8). Controlla anche che i client e il tuo nodo condividano almeno un relay.

I pagamenti falliscono con "no route"

Controlla payment_cltv_limit. Deve stare almeno 576 blocchi sopra max_final_cltv_expiry_delta e non deve superare --max-cltv-expiry del tuo LND. Vedi 4.9.

Problemi di connessione

Mostro si avvia ma non si connette ai relay

Problemi con le operazioni

Un utente riceve "cant-do: too_many_requests" durante il ripristino della sessione

Questo accade quando l'utente ha più ordini (storici + attivi) del valore di max_orders_per_response nella tua configurazione. Il client prova a recuperare tutti gli ordini in una volta e Mostro lo rifiuta. Non è un ban né un blocco temporaneo — continuerà a succedere finché non aggiusti il valore.

# In settings.toml, aumenta il limite:
max_orders_per_response = 50  # il default è 10, il massimo 255

Il valore sta in un singolo byte, quindi 255 è il tetto. Se un utente ha più ordini di così, deve ripulire il suo storico invece che tu continui ad alzare il limite.

Gli ordini non appaiono nei client

Pagamenti falliti

I pagamenti non partono, ma non c'è nessun errore

Controlla se LND è sincronizzato: lncli getinfo. Finché non lo è, Mostro trattiene i pagamenti di proposito e li reinvia appena LND si riprende (5.4).

Gli utenti ricevono rifiuti per "manutenzione" anche se non l'ho mai abilitata

mostro-cli admmaintenancestatus mostra il motivo. lnd_unsynced significa che Mostro l'ha attivata perché LND ha perso la sincronizzazione; la toglie da sola 5 minuti dopo che LND è di nuovo sincronizzato (5.4).

Le commissioni di sviluppo non vengono mai pagate

Su testnet, signet o regtest è previsto: le commissioni di sviluppo si pagano solo su mainnet (4.2).

Gli ordini a prezzo di mercato in una valuta vengono rifiutati

Il tuo nodo non ha un tasso per essa. Controlla gli avvisi price: nel log di avvio: un blocco [price] senza fonti di mercato abilitate, o una stablecoin quotata ma non elencata in fiat_currencies_accepted, sono le cause più comuni. Vedi 4.10 e 4.12.

Problemi di database

Errori database bloccato

ps aux | grep mostrod
# Se ci sono processi multipli, termina quelli extra:
kill <PID>

Ottenere aiuto

  1. Controlla prima i log — la maggior parte degli errori spiega cosa è andato storto
  2. Telegram (Sviluppatori): @mostro_dev
  3. Telegram (Comunità): @MostroP2P
  4. GitHub Issues: github.com/MostroP2P/mostro/issues
  5. DeepWiki: deepwiki.com/MostroP2P/mostro

Quando chiedi aiuto, includi sempre: la tua versione di Mostro, l'output rilevante dei log, e cosa hai già provato.

Appendice: Riferimento Rapido

Posizioni importanti dei file

FileDocker HubNativo
Configurazione~/mostro-config/settings.toml/opt/mostro/settings.toml
Database~/mostro-config/mostro.db/opt/mostro/mostro.db
Cert LND~/mostro-config/lnd/tls.certVaria (controlla config LND)
Macaroon LND~/mostro-config/lnd/mostro.macaroonVaria (controlla config LND)
ServizioN/A/etc/systemd/system/mostro.service
Logdocker logs -f mostrojournalctl -u mostro

Comandi essenziali

# Docker
docker logs -f mostro         # Vedere i log
docker restart mostro          # Riavviare
docker stop mostro             # Fermare

# Nativo (systemd)
systemctl start mostro         # Avviare
systemctl stop mostro          # Fermare
systemctl restart mostro       # Riavviare
systemctl status mostro        # Vedere lo stato
journalctl -u mostro -f        # Vedere i log

# Database
sqlite3 mostro.db "SELECT COUNT(*) FROM orders;"                           # Totale ordini
sqlite3 mostro.db "SELECT COUNT(*) FROM orders WHERE status='success';"    # Operazioni riuscite
sqlite3 mostro.db "SELECT SUM(fee*2 - COALESCE(dev_fee, 0)) FROM orders WHERE status='success';"  # Commissioni nette trattenute dal nodo

Configurazione raccomandata per nodi nuovi

[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 con la tua valuta locale

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

Questa guida è mantenuta dalla comunità Mostro. Hai trovato un errore o vuoi migliorarla?
I contributi sono benvenuti su github.com/MostroP2P/community

Ultimo aggiornamento: Ottobre 2026 · Mostro v0.20.2