Eseguire il Tuo Nodo Mostro

Mostro v0.16.3 — Guida della Comunità · Febbraio 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)
• Il file admin.macaroon (un token di autenticazione)
• L'indirizzo gRPC (tipicamente https://127.0.0.1:10009 se sulla stessa macchina)

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

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

• /root/.lnd/tls.cert
• /root/.lnd/data/chain/bitcoin/mainnet/admin.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/admin.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"

[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/admin.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.16.3

Se LND è su un server diverso:

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

Passo 11: Controllare i log

docker logs -f mostro

Cerca questi messaggi:

• Settings correctly loaded — La configurazione è valida
• Connected to LND — Connessione Lightning riuscita
• Connected to relay — Relay Nostr stabilito

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

Aggiornamento (Docker Hub)

export MOSTRO_TAG=v0.16.3
docker pull mostrop2p/mostro:$MOSTRO_TAG
docker stop mostro
docker rm mostro
docker run -d --name mostro \
  --restart unless-stopped \
  --add-host=host.docker.internal:host-gateway \
  -v ~/mostro-config:/config \
  mostrop2p/mostro:$MOSTRO_TAG

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.

Passo 8: Costruire l'immagine Docker

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

Passo 9: Avviare Mostro

make docker-up

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

# Vedere 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 install sqlx-cli --version 0.6.3
./init_db.sh
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.

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
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.
• 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  # Validità della hold invoice (5 min)

4.6 Anti-Spam

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

4.7 Interfaccia RPC Admin (Opzionale)

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

Abilitala per strumenti di amministrazione come MostriX (interfaccia terminale) per la risoluzione delle dispute.

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

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
chmod +x mostrix-x86_64-unknown-linux-musl
./mostrix-x86_64-unknown-linux-musl

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

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

# Importa le chiavi degli sviluppatori (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

# Scarica manifest e firme
wget https://github.com/MostroP2P/mostrix/releases/latest/download/manifest.txt
wget https://github.com/MostroP2P/mostrix/releases/latest/download/manifest.txt.sig.negrunch
wget https://github.com/MostroP2P/mostrix/releases/latest/download/manifest.txt.sig.arkanoider

# Verifica le firme
gpg --verify manifest.txt.sig.negrunch manifest.txt
gpg --verify manifest.txt.sig.arkanoider manifest.txt

# Verifica che il checksum corrisponda
shasum -a 256 mostrix-x86_64-unknown-linux-musl
# Confronta l'output con l'hash in manifest.txt

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"     # La tua chiave admin dal config Mostro
relays = ["wss://relay.mostro.network"]
currencies_filter = []                          # Vuoto = mostra tutte le valute
user_mode = "admin"                             # Abilita modalità admin

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 = "IL_TUO_CHAT_ID"

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

5.5 Aggiornare Mostro

Docker Hub:

export MOSTRO_TAG=v0.16.3
docker stop mostro
docker rm mostro
docker pull mostrop2p/mostro:$MOSTRO_TAG
docker run -d --name mostro \
  --restart unless-stopped \
  --add-host=host.docker.internal:host-gateway \
  -v ~/mostro-config:/config \
  mostrop2p/mostro:$MOSTRO_TAG

Docker Build:

cd /opt/mostro
git pull origin main
make docker-build
make docker-down
make docker-up

Nativo:

cd /opt/mostro
git pull origin main
cargo build --release
install target/release/mostrod /usr/local/bin
cargo clean
cargo install sqlx-cli --version 0.6.3
sqlx migrate run
systemctl restart mostro.service

5.6 Backup

File critici da salvare: settings.toml (contiene la tua chiave privata Nostr!) e mostro.db (storico degli ordini, reputazione).

# Backup manuale — Docker Hub:
mkdir -p /root/mostro-backups
cp ~/mostro-config/settings.toml /root/mostro-backups/settings.toml.$(date +%Y%m%d)
cp ~/mostro-config/mostro.db /root/mostro-backups/mostro.db.$(date +%Y%m%d)

# Backup manuale — Nativo:
cp /opt/mostro/settings.toml /root/mostro-backups/settings.toml.$(date +%Y%m%d)
cp /opt/mostro/mostro.db /root/mostro-backups/mostro.db.$(date +%Y%m%d)

Backup giornaliero automatizzato (aggiungere al crontab con crontab -e):

# Docker Hub (Opzione A):
0 3 * * * mkdir -p /root/mostro-backups && cp ~/mostro-config/mostro.db /root/mostro-backups/mostro.db.$(date +\%Y\%m\%d) && cp ~/mostro-config/settings.toml /root/mostro-backups/settings.toml.$(date +\%Y\%m\%d)

# Nativo (Opzione C) / Docker Build (Opzione B):
0 3 * * * mkdir -p /root/mostro-backups && cp /opt/mostro/mostro.db /root/mostro-backups/mostro.db.$(date +\%Y\%m\%d) && cp /opt/mostro/settings.toml /root/mostro-backups/settings.toml.$(date +\%Y\%m\%d)

5.7 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';"

# Entrate totali da commissioni (fee del nodo + dev_fee)
sqlite3 /percorso/di/mostro.db "SELECT SUM(fee) as node_fees, SUM(dev_fee) as dev_fees, SUM(fee + dev_fee) as total_fees_sats FROM orders WHERE status = 'success';"

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

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.

8. Considerazioni di Sicurezza

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

"Configuration error: dev_fee_percentage below minimum"

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.

"Failed to connect to LND"

• 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 admin.macaroon siano corretti
• Docker + LND sull'host: usa host.docker.internal

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

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 + dev_fee) FROM orders WHERE status='success';"  # Totale commissioni

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