Eseguire il Tuo Nodo Mostro

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

• Lightning Network — un livello di pagamento rapido e a basso costo per Bitcoin (pensalo come la corsia preferenziale di Bitcoin per pagamenti piccoli e veloci)
• Nostr — un protocollo di comunicazione resistente alla censura (pensalo come un sistema di messaggistica che nessuno può spegnere)

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 una commissione (0,6% di default). Se la tua comunità fa $10.000 in operazioni mensili, sono ~$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)

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:

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

Provider VPS popolari:

• Hostinger — da ~$7/mese (prezzo promozionale; il rinnovo potrebbe essere più alto) (KVM 2: 2 vCPU, 8GB RAM, 100GB NVMe, 8TB banda) · Accetta Bitcoin
• Hetzner — €3,49-8/mese (CX23 da €3,49, buon rapporto qualità-prezzo, basato in UE)
• Digital Ocean — $24/mese (4GB RAM, 2 CPU, 80GB SSD) o $32/mese (4GB RAM, 2 Intel CPU, 120GB NVMe)
• OVH — ~$6-12/mese
• Linode/Akamai — $12/mese
• Lunanode — Accetta pagamenti in 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:

Cosa ti serve dal tuo nodo LND:

• Il file tls.cert (un certificato di sicurezza)
• Un file mostro.macaroon dedicato (un token di autenticazione con solo i permessi di cui Mostro ha bisogno, vedi sotto)
• L'indirizzo gRPC (tipicamente https://127.0.0.1:10009 se sulla stessa macchina)

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

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?

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

• Apri canali verso nodi ben connessi (usa Lightning Network+ o Amboss per trovare buoni peer)
• Ti serve capacità in uscita (per pagare gli acquirenti) e capacità in entrata (per ricevere dai venditori)
• Ottenere liquidità in entrata è solitamente più difficile — considera Lightning Loop, Magma, o servizi di scambio canali

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

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

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

• Opzione A (Docker Hub): La più veloce. Nessuna compilazione, nessun clone. Raccomandata per la maggior parte.
• Opzione B (Docker Build): Costruisci l'immagine localmente dal repository.
• Opzione C (Compilazione nativa): Più controllo, meglio per sysadmin esperti.

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

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

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

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

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:

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

Se LND è su un server diverso:

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

Passo 11: Controllare i log

docker logs -f mostro

Cerca questi messaggi:

• Settings correctly loaded! — La configurazione è valida
• Transport: nip44 (protocol v2, event kind 14) — Protocollo in uso (vedi 4.8)
• Connected to 'wss://...' — Relay Nostr stabilito
• Recorded Lightning node identity <pubkey> — LND raggiunto (solo al primo avvio)

🎉 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.19.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.

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.

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

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

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

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

Creare il servizio systemd:

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

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

[Install]
WantedBy=multi-user.target

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

🎉 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?

• wss://relay.mostro.network — Relay proprio di Mostro, raccomandato
• wss://nos.lol — Relay affidabile e ben connesso
• Aggiungi 3–5 relay per affidabilità. Più relay = migliore disponibilità ma più banda.

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.

• 0.006 = 0,6% (ciascuna parte paga 0,3%)
• 0.01 = 1,0% (ciascuna parte paga 0,5%)
• 0 = gratis (buono per far crescere la base utenti)

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.

• 0.30 = 30% (default) — su 600 sat, 180 vanno al fondo di sviluppo
• Minimo: 10% (0.10), Massimo: 100% (1.0)
• Pagata dal tuo nodo dai suoi guadagni, non addebitata agli utenti
• Tutti i pagamenti verificabili pubblicamente tramite eventi Nostr (kind 8383)

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

• max_order_amount: Operazione più grande in satoshi. Configuralo in base alla capacità dei tuoi canali Lightning.
• min_payment_amount: Operazione minima in satoshi. 1.000 o 10.000 è più pratico di 100.
• max_orders_per_response: Numero massimo di ordini che Mostro restituisce in una singola query. Se un utente accumula più ordini di questo limite (ad esempio durante il ripristino della sessione dal client mobile), riceverà un errore cant-do: too_many_requests e non potrà recuperare i suoi ordini. Se i tuoi utenti operano frequentemente, aumenta questo valore (ad esempio 50 o 100). Il valore predefinito di 10 potrebbe non essere sufficiente.
• fiat_currencies_accepted: Usa codici ISO 4217. Array vuoto [] accetta tutte le valute.

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 resta aperto
expiration_seconds = 900     # Tempo per completare (15 min)
hold_invoice_expiration_window = 300  # Tempo che ha il taker per pagare la fattura o fornirne una di incasso (5 min)

4.6 Anti-Spam

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

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.

4.8 Protocollo di Trasporto

Un nodo Mostro parla un solo protocollo, scelto qui:

[mostro]
transport = "nip44"

Il tuo nodo annuncia quale protocollo parla nel suo evento info kind 38385, quindi i client compatibili scelgono il formato da soli. Mostro Mobile, Mostrix e mostro-cli supportano v2.

Il trasporto v2 permette anche un filtro anti-spam più fine di quello in 4.6. 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

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

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.

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

4.11 Altri Blocchi Opzionali

Altri tre blocchi che potresti incontrare in un template recente. Nessuno è obbligatorio.

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)

Le cauzioni anti-abuso ([anti_abuse_bond]) possono richiedere una cauzione tramite hold invoice ai taker, ai maker o a entrambi, così abbandonare un'operazione ha un costo. Disabilitato per default e ancora in rilascio a fasi. Leggi il docs/ANTI_ABUSE_BOND.md del progetto prima di abilitarlo su un nodo in produzione.

L'escrow Cashu ([cashu]) è una modalità sperimentale che gira senza LND e tiene l'escrow in token Cashu su una singola mint. Non è ancora utilizzabile per operare davvero, le azioni di trade vengono ancora rifiutate, e non si può combinare con le cauzioni anti-abuso. Menzionato qui perché sappia cos'è quel blocco quando lo vedi.

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?

• L'acquirente dice di aver pagato, il venditore dice di non aver ricevuto
• Il venditore si rifiuta di rilasciare i Bitcoin dopo aver ricevuto il pagamento
• Una delle parti smette di rispondere

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

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.

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.

5.2 Mostrix — Il tuo strumento di amministrazione

Mostrix è un client basato su terminale (TUI) per la risoluzione delle dispute. Se esegui un nodo Mostro, hai bisogno di Mostrix.

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)
wget https://github.com/MostroP2P/mostrix/releases/latest/download/mostrix-aarch64-unknown-linux-musl

# Windows
# Scarica mostrix-x86_64-pc-windows-gnu.exe dalla pagina delle release

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

curl https://raw.githubusercontent.com/MostroP2P/mostrix/main/keys/negrunch.asc | gpg --import
curl https://raw.githubusercontent.com/MostroP2P/mostrix/main/keys/arkanoider.asc | gpg --import

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

# Verifica ogni firma che hai scaricato
gpg --verify manifest.txt.sig.arkanoider manifest.txt

# Poi confronta l'hash del binario con il manifest
shasum -a 256 mostrix-x86_64-unknown-linux-musl
grep mostrix-x86_64-unknown-linux-musl manifest.txt

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)
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 genera automaticamente un file ~/.mostrix/settings.toml con valori predefiniti sensati, inclusa una nuova coppia di chiavi Nostr. Il tuo npub generato verrà mostrato nel terminale.

# Modifica la configurazione
nano ~/.mostrix/settings.toml

# Cambia questa riga con la pubkey del TUO nodo Mostro:
mostro_pubkey = "LA_TUA_PUBKEY_MOSTRO_HEX"

Per la modalità admin (risoluzione dispute), configura anche:

# ~/.mostrix/settings.toml
mostro_pubkey = "LA_TUA_PUBKEY_MOSTRO_HEX"
nsec_privkey = "nsec1la_tua_chiave_personale"  # Auto-generata al primo avvio
admin_privkey = "nsec1la_tua_chiave_admin"        # Il nsec del daemon stesso — vedi sotto
relays = ["wss://relay.mostro.network"]
currencies_filter = []                          # Vuoto = mostra tutte le valute
user_mode = "admin"                             # Abilita modalità admin

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

5.3 mostro-watchdog — Notifiche dispute su Telegram

mostro-watchdog monitora il tuo nodo Mostro per le dispute e invia avvisi istantanei tramite Telegram. Essenziale per tempi di risposta rapidi.

Opzione A: Installazione automatica (Raccomandata)

# Scarica ed esegui lo script di installazione
curl -fsSL https://raw.githubusercontent.com/MostroP2P/mostro-watchdog/main/install.sh | bash

Opzione B: Download manuale del binario

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

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

Opzione C: Compilare dal codice sorgente

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:

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

[mostro]
pubkey = "LA_TUA_PUBKEY_MOSTRO"

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

[telegram]
bot_token = "IL_TUO_BOT_TOKEN"
chat_id = -1001234567890

5.4 Monitoraggio dell'uptime

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

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. Leggerlo da un relay è il modo più rapido di confermare che il mondo esterno vede quello che credi.

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

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, quindi una nuova opzione ha effetto solo quando la aggiungi: confronta il tuo file con il nuovo settings.tpl.toml.
2. Fai un backup del database con i comandi di 5.6. Ti serve per tornare indietro.

Docker Hub (docker run)

export MOSTRO_TAG=v0.19.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 Hub (Docker Compose)

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

Nativo

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

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.

5.6 Backup

File critici da salvare: settings.toml, il file .env se ci tieni il tuo nsec (vedi 4.1), e mostro.db (storico ordini, reputazione).

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

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

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)

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

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

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

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.

5.9 Comandi da Operatore con mostro-cli

Mostrix è il modo comodo per lavorare le dispute, ma mostro-cli copre lo stesso terreno da shell e ha alcuni comandi 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.

# Lavoro sulle dispute (via Nostr, richiede ADMIN_NSEC)
export ADMIN_NSEC=nsec1...
mostro-cli listdisputes
mostro-cli admtakedispute -d <dispute-id>
mostro-cli admsenddm -p <npub> -m "messaggio a una parte"
mostro-cli admsettle -o <order-id>      # rilascia all'acquirente
mostro-cli admcancel -o <order-id>      # rimborsa il venditore

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

Un altro gruppo di comandi passa dal gRPC di amministrazione invece che da Nostr, quindi richiedono MOSTRO_RPC_URL e MOSTRO_RPC_TOKEN anziché ADMIN_NSEC, e l'interfaccia RPC abilitata (vedi 4.7).

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 della cauzione di un taker, 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.

6. Analisi dei Costi

Costi operativi mensili

Costi una tantum / di capitale

Potenziale di entrate

Impegno di tempo

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?

Tecnicamente sì (usando Start9 o simili), ma non è raccomandato per la produzione a causa delle limitazioni di CPU e RAM. Un VPS è più affidabile.

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'app client Mostro (come Mostro Mobile o mostro-cli) e della chiave pubblica del tuo Mostro (npub). Aggiungono la tua npub al loro client, e il client comunica attraverso i relay Nostr. Non serve una connessione diretta.

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.

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

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.

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

• Verifica che LND sia in esecuzione: lncli getinfo
• Controlla che lnd_grpc_host corrisponda all'indirizzo del tuo LND
• Verifica che i percorsi di tls.cert e mostro.macaroon siano corretti
• Verifica che il macaroon abbia i permessi indicati in 2.2
• Docker + LND sull'host: usa host.docker.internal. L'Opzione B richiede inoltre il mapping extra_hosts.

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.

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

Controlla la riga Transport: nei tuoi log. Un nodo su nip44 è invisibile ai client che parlano solo il protocollo v1, e un nodo su gift-wrap è invisibile ai client v2. Vedi 4.8.

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

• Controlla le URL dei relay (devono iniziare con wss://)
• Assicurati che il firewall del tuo VPS permetta connessioni in uscita sulla porta 443
• Prova con relay diversi — alcuni potrebbero essere temporaneamente offline

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

• Controlla le connessioni ai relay nei log
• Assicurati che i client usino gli stessi relay del tuo nodo

Pagamenti falliti

• Controlla la liquidità: lncli listchannels
• Assicurati di avere sufficiente capacità in uscita
• Controlla l'impostazione max_routing_fee

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

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