Executando Seu Próprio Nó Mostro

Mostro v0.16.3 — Guia da Comunidade · Fevereiro 2026

1. O que é Mostro e por que sua comunidade deveria executar um?

Mostro é uma exchange peer-to-peer de Bitcoin que permite às pessoas comprar e vender Bitcoin usando moedas locais (dólares, euros, reais — qualquer moeda) sem precisar fornecer documentos de identidade (KYC). Pense nele como um marketplace descentralizado onde compradores e vendedores podem negociar diretamente.

Funciona usando duas tecnologias:

• Lightning Network — uma camada de pagamentos rápidos e de baixo custo para Bitcoin (pense nela como a via expressa do Bitcoin para pagamentos pequenos e ágeis)
• Nostr — um protocolo de comunicação resistente à censura (pense nele como um sistema de mensagens que ninguém pode desligar)

Mostro atua como um coordenador de custódia — retém os Bitcoin do vendedor em um "cofre" temporário (chamado hold invoice) até que o comprador confirme que enviou o pagamento em moeda local. Mostro nunca controla realmente os fundos de ninguém; apenas os retém brevemente durante a negociação.

Por que sua comunidade iria querer executar um nó Mostro?

1. Receita de taxas — Cada operação gera uma taxa (0,6% por padrão). Se sua comunidade faz $10.000 em operações mensais, são ~$60/mês em taxas.
2. Trading P2P sem KYC — Os membros da sua comunidade podem comprar e vender Bitcoin sem fornecer documentos de identidade. Especialmente importante em regiões com moedas instáveis ou regulamentações restritivas.
3. Disputas no seu idioma — Quando uma operação dá errado, a sua comunidade resolve, no seu idioma, entendendo os seus métodos de pagamento locais.
4. Independência — Nenhuma empresa pode fechar sua exchange. Nenhum governo pode pressionar um único operador a fechá-la.
5. Personalização — Você escolhe quais moedas suportar, quais métodos de pagamento permitir e quais taxas cobrar.

Como Mostro Funciona (Simplificado)

Se algo der errado (ex: Bob diz que pagou mas Alice não recebeu), qualquer uma das partes pode abrir uma disputa, e os árbitros designados da sua comunidade investigam e resolvem.

2. Pré-requisitos — O que você precisa antes de começar

2.1 Um Servidor (VPS)

Um VPS (Servidor Virtual Privado) é um computador em um data center que funciona 24/7. Você alugará um para hospedar seu nó Mostro.

Especificações mínimas:

Custo mensal estimado: $10–$24/mês.

Provedores de VPS populares:

• Hostinger — a partir de ~$7/mês (preço promocional; renovação pode ser maior) (KVM 2: 2 vCPU, 8GB RAM, 100GB NVMe, 8TB largura de banda) · Aceita Bitcoin
• Hetzner — €3,49-8/mês (CX23 a partir de €3,49, bom custo-benefício, baseado na UE)
• Digital Ocean — $24/mês (4GB RAM, 2 CPUs, 80GB SSD) ou $32/mês (4GB RAM, 2 Intel CPUs, 120GB NVMe)
• OVH — ~$6-12/mês
• Linode/Akamai — $12/mês
• Lunanode — Aceita pagamentos em Bitcoin

Você precisa se sentir confortável conectando-se a um servidor via SSH. Se nunca fez isso, procure um tutorial sobre "Conectar via SSH a um VPS" — é mais simples do que parece.

2.2 Um Nó Lightning Network (LND)

Lightning Network é um sistema "camada 2" construído sobre o Bitcoin que permite pagamentos rápidos e baratos. Para executar o Mostro, você precisa de um nó LND (Lightning Network Daemon) — o software Lightning específico com o qual o Mostro trabalha.

Suas opções:

O que você precisa do seu nó LND:

• O arquivo tls.cert (um certificado de segurança)
• O arquivo admin.macaroon (um token de autenticação)
• O endereço gRPC (tipicamente https://127.0.0.1:10009 se na mesma máquina)

2.3 Liquidez Lightning

Para facilitar as operações, seu nó Lightning precisa de canais com Bitcoin neles. Pense nos canais Lightning como túneis de pagamento pré-financiados. O Bitcoin dentro desses canais é sua "liquidez".

Quanto você precisa?

Comece pequeno, cresça gradualmente. Comece com o suficiente para as necessidades iniciais da sua comunidade e monitore o feedback. Quando os traders reportarem falhas em ordens por capacidade insuficiente, esse é o sinal para adicionar mais. Ouça sua comunidade.

Obtendo liquidez:

• Abra canais para nós bem conectados (use Lightning Network+ ou Amboss para encontrar bons pares)
• Você precisa de capacidade de saída (para pagar compradores) e capacidade de entrada (para receber de vendedores)
• Obter liquidez de entrada geralmente é mais difícil — considere Lightning Loop, Magma, ou serviços de troca de canais

2.4 Chaves Nostr

Seu nó Mostro precisa de sua própria identidade na rede Nostr — um par de chaves criptográficas com uma chave pública (o endereço do seu nó) e uma chave privada (seu segredo).

Gerando chaves Nostr seguras localmente com rana:

# Instalar Rust (se não estiver instalado)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# Instalar rana - gerador local de chaves Nostr
cargo install rana

# Gerar um novo par de chaves (com frase seed de 12 palavras)
rana --generate 12

O Rana gerará sua chave privada (nsec), chave pública (npub) e uma frase seed de backup. Guarde tudo com segurança! Nota: executar rana sem argumentos inicia mineração PoW (dificuldade 10) que pode levar minutos — use --generate para geração instantânea. Nunca gere chaves importantes usando serviços online.

2.5 Nível de conhecimento técnico

💡 Nossa recomendação: Se sua comunidade tem alguém confortável com a linha de comando Linux, essa pessoa pode lidar com a instalação Docker. A compilação nativa requer experiência em administração de sistemas. A configuração do nó Lightning é a parte mais complexa — considere pedir ajuda a alguém experiente, ou usar uma solução nó-em-caixa.

3. Instalação Passo a Passo

Todas as opções de instalação compartilham os mesmos primeiros passos. Depois escolha a opção que preferir:

• Opção A (Docker Hub): A mais rápida. Sem compilar, sem clonar. Recomendada para a maioria.
• Opção B (Docker Build): Construa a imagem localmente a partir do repositório.
• Opção C (Compilação nativa): Mais controle, melhor para sysadmins experientes.

Todas assumem que você já tem: ✅ Um VPS com Ubuntu · ✅ Acesso SSH · ✅ Um nó LND funcionando.

Passos Comuns (para as 3 opções)

Passo 1: Conecte-se ao seu VPS

ssh root@SEU_ENDERECO_IP_DO_VPS

Passo 2: Atualize o sistema

# Baixar as informações mais recentes dos pacotes
apt update

# Instalar todas as atualizações disponíveis
apt upgrade -y

Passo 3: Instalar Docker e Docker Compose

# Instalar Docker com o script oficial
curl -fsSL https://get.docker.com | sh

# Verificar se Docker está instalado
docker --version

# Verificar Docker Compose
docker compose version

Passo 4: Instalar ferramentas adicionais

apt install -y git make

✅ Passos comuns concluídos. Agora escolha sua opção de instalação:

Opção A: Docker Hub (A mais rápida — Recomendada)

Execute o Mostro diretamente do Docker Hub sem clonar o repositório ou compilar. Perfeito para deployments em VPS.

Passo 5: Criar diretório de configuração

mkdir -p ~/mostro-config/lnd

Passo 6: Obter o template de configuração

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

Passo 7: Copiar credenciais LND

cp /caminho/para/seu/tls.cert ~/mostro-config/lnd/tls.cert
cp /caminho/para/seu/admin.macaroon ~/mostro-config/lnd/admin.macaroon

Se o LND está na mesma máquina, os caminhos típicos são:

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

Passo 8: Editar a configuração

nano ~/mostro-config/settings.toml

Alterações necessárias:

[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 no mesmo VPS
# Ou usar 'https://SEU_IP_LND:10009' se LND em servidor diferente

[database]
url = "sqlite:///config/mostro.db"

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

[mostro]
fee = 0.006                    # 0,6% taxa por operação
max_order_amount = 1000000     # Ordem máxima em sats
min_payment_amount = 100       # Ordem mínima em sats
fiat_currencies_accepted = ['USD', 'BRL']  # Suas moedas

Salvar: Ctrl+X, depois Y, depois Enter.

Passo 9: Ajustar permissões

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: Executar o container

Se o LND está no mesmo 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 o LND está em um servidor diferente:

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

Passo 11: Verificar os logs

docker logs -f mostro

Procure estas mensagens:

• Settings correctly loaded — A configuração é válida
• Connected to LND — Conexão Lightning bem-sucedida
• Connected to relay — Relay Nostr estabelecido

🎉 Parabéns! Se vir conexões bem-sucedidas nos logs, seu nó Mostro está funcionando!

Atualização (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

Opção B: Docker Build (Construir imagem localmente)

Passo 5: Baixar Mostro

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

Passo 6: Configurar arquivos

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

Passo 7: Editar o arquivo de configuração

nano config/settings.toml

Edite as mesmas configurações da Opção A, Passo 8.

Passo 8: Construir a imagem 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: Iniciar Mostro

make docker-up

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

# Ver logs
docker compose -f docker/compose.yml logs -f mostro

🎉 Parabéns! Se vir conexões bem-sucedidas, seu nó Mostro está funcionando!

Opção C: Compilação Nativa (Para operadores técnicos)

Passo 5: Instalar Rust

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

Passo 6: Instalar dependências de compilação

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

Passo 7: Baixar e compilar Mostro

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

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

Passos 8–10: Instalar, inicializar e limpar

install target/release/mostrod /usr/local/bin
cargo install sqlx-cli --version 0.6.3
./init_db.sh
cargo clean  # Economiza 2+ GB de espaço

Passos 11–12: Criar usuário e configurar

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

Edite as mesmas configurações da Opção A, Passo 8.

Passos 13–15: Teste, permissões e serviço systemd

# Teste de execução
/usr/local/bin/mostrod -d /opt/mostro

# Definir permissões
chown -R mostro:mostro /opt/mostro

Criar o serviço 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

🎉 Parabéns! Seu nó Mostro está executando como serviço do sistema.

4. Configuração em Detalhe

O arquivo settings.toml controla tudo sobre seu nó Mostro.

4.1 Chaves Nostr — A identidade do seu nó

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

Quais relays usar?

• wss://relay.mostro.network — Relay próprio do Mostro, recomendado
• wss://nos.lol — Relay confiável e bem conectado
• Adicione 3–5 relays para confiabilidade. Mais relays = melhor disponibilidade mas mais largura de banda.

4.2 Taxas — Como você gera receita

[mostro]
fee = 0.006
dev_fee_percentage = 0.30

Taxa de trading (fee): Percentual cobrado por operação, dividido entre comprador e vendedor.

• 0.006 = 0,6% (cada parte paga 0,3%)
• 0.01 = 1,0% (cada parte paga 0,5%)
• 0 = grátis (bom para fazer crescer sua base de usuários)

Exemplo: Em uma operação de 100.000 sats com fee = 0.006: O comprador paga 300 sats, o vendedor paga 300 sats, seu nó ganha 600 sats no total.

Taxa de desenvolvimento (dev_fee_percentage): Um percentual dos seus ganhos de taxas que vai para o desenvolvimento do Mostro.

• 0.30 = 30% (padrão) — de 600 sats, 180 vão para o fundo de desenvolvimento
• Mínimo: 10% (0.10), Máximo: 100% (1.0)
• Paga pelo seu nó dos seus ganhos, não cobrada dos usuários
• Todos os pagamentos auditáveis publicamente via eventos Nostr (kind 8383)

4.3 Limites de ordens e moedas

[mostro]
max_order_amount = 1000000
min_payment_amount = 100
fiat_currencies_accepted = ['USD', 'BRL', 'ARS', 'CUP']

• max_order_amount: Maior operação em satoshis. Configure baseado na capacidade dos seus canais Lightning.
• min_payment_amount: Operação mínima em satoshis. 1.000 ou 10.000 é mais prático que 100.
• fiat_currencies_accepted: Use códigos ISO 4217. Array vazio [] aceita todas as moedas.

4.4 Perfil do nó (Opcional mas recomendado)

[mostro]
name = "Brasil Mostro"
about = "Exchange P2P de Bitcoin para o Brasil. Suporte em português."
picture = "https://exemplo.com/seu-logo.png"
website = "https://site-da-sua-comunidade.com"

Estes configuram o perfil do seu Mostro no Nostr (NIP-01 kind 0 metadata). Os clientes exibem essas informações para que os usuários saibam em qual Mostro estão operando.

4.5 Tempos e expiração

[mostro]
expiration_hours = 24        # Quanto tempo uma ordem fica aberta
expiration_seconds = 900     # Tempo para completar (15 min)
hold_invoice_expiration_window = 300  # Validade da hold invoice (5 min)

4.6 Anti-Spam

[mostro]
pow = 0  # 0 = desabilitado; 10-20 = moderado. Comece com 0.

4.7 Interface RPC Admin (Opcional)

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

Habilite para ferramentas de administração como MostriX (interface de terminal) para resolução de disputas.

5. Operando Seu Nó Mostro

5.1 Como funcionam as disputas

Disputas são sua responsabilidade operacional mais importante.

Quando ocorrem disputas?

• O comprador diz que pagou, o vendedor diz que não recebeu
• O vendedor se recusa a liberar os Bitcoin após receber o pagamento
• Uma das partes deixa de responder

O processo de disputa:

1. O usuário abre uma disputa — Uma das partes clica "Disputa" no cliente
2. Mostro marca a ordem — O status muda para "Disputa", os fundos permanecem bloqueados
3. O árbitro assume o caso — Um admin designado ao seu nó investiga
4. Investigação — Comunica-se com ambas as partes, solicita provas
5. Resolução — O árbitro decide: liberar ao comprador, ou devolver ao vendedor

5.2 Mostrix — Sua ferramenta de administração

Mostrix é um cliente baseado em terminal (TUI) para resolução de disputas. Se você executa um nó Mostro, precisa do Mostrix.

Opção A: Baixar binário pré-compilado (Recomendado)

Baixe a última versão para sua plataforma em 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
# Baixe mostrix-x86_64-pc-windows-gnu.exe da página de releases

# Importar chaves dos desenvolvedores (uma única vez)
curl https://raw.githubusercontent.com/MostroP2P/mostrix/main/keys/negrunch.asc | gpg --import
curl https://raw.githubusercontent.com/MostroP2P/mostrix/main/keys/arkanoider.asc | gpg --import

# Baixar manifest e assinaturas
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

# Verificar assinaturas
gpg --verify manifest.txt.sig.negrunch manifest.txt
gpg --verify manifest.txt.sig.arkanoider manifest.txt

# Verificar se o checksum corresponde
shasum -a 256 mostrix-x86_64-unknown-linux-musl
# Compare a saída com o hash em manifest.txt

Opção B: Compilar do código fonte

Se preferir compilar do código fonte ou precisar de uma plataforma não disponível nas releases:

# Instalar dependências (Ubuntu/Debian)
sudo apt install -y cmake build-essential pkg-config

# Instalar Rust (se ainda não instalado)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

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

# Executar
./target/release/mostrix

Primeira execução e configuração

Na primeira execução, Mostrix gera automaticamente um arquivo ~/.mostrix/settings.toml com valores padrão sensatos, incluindo um novo par de chaves Nostr. Seu npub gerado será exibido no terminal.

# Editar a configuração
nano ~/.mostrix/settings.toml

# Altere esta linha para a pubkey do SEU nó Mostro:
mostro_pubkey = "SUA_PUBKEY_MOSTRO_HEX"

Para modo admin (resolução de disputas), configure também:

# ~/.mostrix/settings.toml
mostro_pubkey = "SUA_PUBKEY_MOSTRO_HEX"
nsec_privkey = "nsec1sua_chave_pessoal"      # Auto-gerada na primeira execução
admin_privkey = "nsec1sua_chave_admin"       # Sua chave admin do config do Mostro
relays = ["wss://relay.mostro.network"]
currencies_filter = []                        # Vazio = mostrar todas as moedas
user_mode = "admin"                           # Habilitar modo admin

5.3 mostro-watchdog — Notificações de disputas no Telegram

mostro-watchdog monitora seu nó Mostro para disputas e envia alertas instantâneos via Telegram. Essencial para tempos de resposta rápidos.

Opção A: Instalação automática (Recomendada)

# Baixe e execute o script de instalação
curl -fsSL https://raw.githubusercontent.com/MostroP2P/mostro-watchdog/main/install.sh | bash

Opção B: Download manual do binário

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

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

Opção C: Compilar do código fonte

git clone https://github.com/MostroP2P/mostro-watchdog.git
cd mostro-watchdog
cargo build --release
sudo cp target/release/mostro-watchdog /usr/local/bin/

Configuração:

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

[mostro]
pubkey = "SUA_PUBKEY_MOSTRO"

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

[telegram]
bot_token = "SEU_BOT_TOKEN"
chat_id = "SEU_CHAT_ID"

5.4 Monitoramento de uptime

Seu nó precisa estar funcionando 24/7.

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

# Docker Hub (Opção A)
docker ps --filter name=mostro
docker logs -f mostro

# Docker Build (Opção B)
docker compose -f /opt/mostro/docker/compose.yml ps
docker compose -f /opt/mostro/docker/compose.yml logs -f mostro

5.5 Atualizando 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 Backups

Arquivos críticos para backup: settings.toml (contém sua chave privada Nostr!) e mostro.db (histórico de ordens, reputação).

# Backup manual — 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 manual — 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 diário automatizado (adicionar ao crontab com crontab -e):

# Docker Hub (Opção 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 (Opção C) / Docker Build (Opção 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 Revisando a atividade de operações

# Contar todas as ordens
sqlite3 /caminho/para/mostro.db "SELECT COUNT(*) FROM orders;"

# Operações bem-sucedidas recentes
sqlite3 /caminho/para/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;"

# Ordens pendentes
sqlite3 /caminho/para/mostro.db "SELECT id, fiat_code, fiat_amount, status, created_at FROM orders WHERE status = 'pending';"

# Receita total de taxas (taxa do nó + dev_fee)
sqlite3 /caminho/para/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. Análise de Custos

Custos operacionais mensais

Custos únicos / de capital

Potencial de receita

Compromisso de tempo

7. Perguntas Frequentes

Preciso ser desenvolvedor para executar um nó Mostro?

Não, mas precisa se sentir confortável com operações básicas de linha de comando (digitar comandos, editar arquivos de texto). O caminho Docker (Opção A) foi projetado para ser acessível.

Posso executar Mostro em um Raspberry Pi?

Tecnicamente sim (usando Start9 ou similar), mas não é recomendado para produção devido às limitações de CPU e RAM. Um VPS é mais confiável.

Posso usar Core Lightning (CLN) em vez de LND?

Não. Mostro atualmente suporta apenas LND, porque depende da implementação específica de hold invoices do LND. O suporte para outras implementações pode chegar no futuro.

Como os usuários se conectam ao meu Mostro?

Os usuários precisam de um app cliente Mostro (como Mostro Mobile ou mostro-cli) e da chave pública do seu Mostro (npub). Eles adicionam sua npub ao cliente, e o cliente se comunica através dos relays Nostr. Não é necessária conexão direta.

Posso executar múltiplas instâncias de Mostro?

Sim, mas cada uma precisa de seu próprio par de chaves Nostr, nó LND (ou pelo menos canais/liquidez separados), e configuração.

É legal?

Depende muito da sua jurisdição. Mostro é software para trading peer-to-peer. Em algumas jurisdições, operar uma exchange P2P pode exigir licenças. Verifique as regulamentações locais e procure assessoria jurídica.

Quanta largura de banda o Mostro usa?

Muito pouca — principalmente pequenos eventos Nostr. Alguns GB por mês é típico mesmo com volume moderado.

O que acontece se meu nó ficar offline?

Ordens pendentes eventualmente expiram. Operações ativas com fundos bloqueados continuam quando você volta a ficar online. Se ficar offline por muito tempo, os usuários podem perder a confiança.

Posso mudar minha chave Nostr depois?

Pode, mas perderá a identidade e reputação do seu nó. Os usuários o verão como um Mostro novo. Trate sua chave como sua identidade de marca.

Posso perder dinheiro executando um nó Mostro?

Sim, é possível: os fundos dos canais Lightning podem estar em risco por bugs (raro); o fechamento forçado de canais durante períodos de taxas altas pode ser custoso; os custos de VPS são contínuos.

A liquidez Lightning está "em risco"?

Sua liquidez Lightning é sua. Não está em risco pelo Mostro em si — hold invoices são bloqueios temporários. No entanto, aplicam-se os riscos padrão da Lightning Network (fechamentos forçados, canais travados, bugs).

Quando vou atingir o ponto de equilíbrio?

Depende dos seus custos e volume de operações. Com $20/mês de custos e 0,6% de taxa, você precisa de ~$5.000/mês em operações para cobrir custos (antes da taxa de desenvolvimento). A maioria das comunidades leva 3–6 meses para construir volume significativo.

8. Considerações de Segurança

Operando sob regimes autoritários

Se você opera em um país com governo autoritário, privacidade não é opcional — é um requisito de segurança.

1. Execute seu nó Mostro atrás de Tor e/ou uma VPN. Isso oculta o IP do seu servidor dos relays Nostr.
2. Se Tor/VPN não é possível (comum em países em desenvolvimento com internet lenta), publique eventos apenas em relays que você possui ou confia.
3. Tenha muito cuidado com quais relays você usa. No futuro, governos podem criar relays Nostr especificamente para coletar endereços IP.
4. Considere também a privacidade do seu nó Lightning. Executar LND atrás de Tor é possível e recomendado em ambientes sensíveis.

9. Solução de Problemas

Mostro não inicia

"Configuration error: dev_fee_percentage below minimum"

Defina dev_fee_percentage em pelo menos 0.10 no settings.toml.

Arquivo de configuração ou banco de dados não encontrado

Certifique-se de que o flag -d aponte para o diretório contendo settings.toml. Para Docker Hub: verifique se ~/mostro-config/settings.toml existe.

"Failed to connect to LND"

• Verifique se o LND está executando: lncli getinfo
• Confira se lnd_grpc_host corresponde ao endereço do seu LND
• Verifique se os caminhos de tls.cert e admin.macaroon estão corretos
• Docker + LND no host: use host.docker.internal

Problemas de conexão

Mostro inicia mas não conecta aos relays

• Verifique as URLs dos relays (devem começar com wss://)
• Certifique-se de que o firewall do seu VPS permite conexões de saída na porta 443
• Tente relays diferentes — alguns podem estar temporariamente fora do ar

Problemas com operações

Ordens não aparecem nos clientes

• Verifique as conexões com relays nos logs
• Certifique-se de que os clientes usem os mesmos relays que seu nó

Pagamentos falhando

• Verifique a liquidez: lncli listchannels
• Certifique-se de ter capacidade de saída suficiente
• Verifique a configuração max_routing_fee

Problemas de banco de dados

Erros de banco de dados bloqueado

ps aux | grep mostrod
# Se houver múltiplos processos, encerre os extras:
kill <PID>

Obtendo ajuda

1. Verifique os logs primeiro — a maioria dos erros explica o que deu errado
2. Telegram (Desenvolvedores): @mostro_dev
3. Telegram (Comunidade): @MostroP2P
4. GitHub Issues: github.com/MostroP2P/mostro/issues
5. DeepWiki: deepwiki.com/MostroP2P/mostro

Ao pedir ajuda, sempre inclua: sua versão do Mostro, a saída relevante dos logs, e o que já tentou.

Apêndice: Referência Rápida

Localizações importantes de arquivos

Comandos essenciais

# Docker
docker logs -f mostro         # Ver logs
docker restart mostro          # Reiniciar
docker stop mostro             # Parar

# Nativo (systemd)
systemctl start mostro         # Iniciar
systemctl stop mostro          # Parar
systemctl restart mostro       # Reiniciar
systemctl status mostro        # Ver status
journalctl -u mostro -f        # Ver logs

# Banco de dados
sqlite3 mostro.db "SELECT COUNT(*) FROM orders;"                           # Total de ordens
sqlite3 mostro.db "SELECT COUNT(*) FROM orders WHERE status='success';"    # Operações bem-sucedidas
sqlite3 mostro.db "SELECT SUM(fee + dev_fee) FROM orders WHERE status='success';"  # Total de taxas

Configuração recomendada para nós novos

[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 = ['BRL']  # Mude para sua moeda local

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