Executando Seu Próprio Nó Mostro

Mostro v0.20.2 — Guia da Comunidade · Outubro de 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:

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 a taxa que você definir (o template vem com 0; 0,6% é uma escolha comum). A 0,6%, uma comunidade que faz $10.000 em operações mensais ganha ~$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)

1. Alice quer VENDER Bitcoin por $50 USD → Cria uma ordem no Mostro
2. Bob quer COMPRAR Bitcoin com $50 USD → Vê a ordem de Alice e a aceita
3. Mostro cria um "cofre" (hold invoice) → Alice envia seus Bitcoin para o cofre
4. Bob envia $50 para Alice via transferência bancária, Pix, dinheiro, etc. → Bob pressiona "Fiat Enviado" no app
5. Alice confirma que recebeu os $50 → Pressiona "Liberar"
6. Mostro libera os Bitcoin do cofre para Bob → Operação concluída! ✓

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:

RecursoMínimoRecomendado
CPU2 vCPUs (compartilhadas)2+ vCPUs
RAM2 GB4 GB
Armazenamento60 GB SSD100 GB SSD
Largura de banda3 TB/mês3+ TB/mês
SOUbuntu 22.04+ LTSUbuntu 24.04 LTS

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

Esses valores são só para o Mostro. Se o LND roda no mesmo VPS, some pelo menos 2 GB de RAM e o disco que o backend Bitcoin dele precisa (veja 2.2).

Provedores de VPS populares:

💡 Dica

Muitos provedores de VPS aceitam pagamentos em Bitcoin. Procure essa opção se quiser manter coerência com a filosofia 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:

OpçãoDificuldadeCustoNotas
Usar um nó LND existenteFácilGrátis (se tiver um)Melhor se alguém já tem um
Executar LND no mesmo VPSDifícilVPS maior + liquidez4GB+ de RAM e disco para o backend Bitcoin (veja abaixo)
Solução nó-em-caixaMédio$200-600 + liquidezStart9, Umbrel, RaspiBlitz
StartOS com pacote MostroMais fácil$300-600 + liquidezStart9 tem um pacote Mostro de um clique
Usar Voltage.cloudFácilA partir de ~$20/mês + liquidezVoltage — LND hospedado com infraestrutura gerenciada
⚠️ Importante

Mostro requer especificamente LND (não CLN/Core Lightning, não Eclair, não LDK). Certifique-se de que seu nó Lightning execute LND.

O que você precisa do seu nó LND:

Gere um macaroon dedicado para o Mostro. Não entregue ao Mostro o seu admin.macaroon: ele concede controle total sobre o seu nó e seus fundos. Crie um macaroon que contenha apenas as permissões que o Mostro realmente usa (ler informações do nó, listar canais para o relatório de saúde, criar/liquidar/cancelar hold invoices, enviar e acompanhar pagamentos).

Primeiro escolha um root key ID que ainda não esteja em uso. Revogar um macaroon revoga todos os macaroons que compartilham o seu ID, então reaproveitar um levaria embora credenciais alheias. O ID 0 pertence aos macaroons do próprio LND, então escolha um número livre diferente de zero e anote-o:

lncli listmacaroonids

Depois crie o macaroon com o ID escolhido (7 neste exemplo, substitua pelo seu):

lncli bakemacaroon --root_key_id 7 \
  --save_to /root/.lnd/data/chain/bitcoin/mainnet/mostro.macaroon \
  info:read invoices:read invoices:write offchain:read offchain:write

Este macaroon não pode abrir ou fechar canais, mover fundos on-chain nem alterar a configuração do seu nó. Se algum dia vazar, revogue-o com lncli deletemacaroonid 7, usando o mesmo ID com que o criou, e gere um novo.

Se você não consegue escrever no diretório de dados do LND (um container, um nó-em-caixa, um nó hospedado), omita --save_to: o lncli então imprime o macaroon em hexadecimal, e você o transforma em arquivo onde o Mostro roda. O lncli também pode criá-lo a partir de outra máquina, apontado para o nó com as credenciais de admin dele:

lncli --rpcserver=NODE_ADDRESS:10009 --tlscertpath=tls.cert --macaroonpath=admin.macaroon \
  bakemacaroon --root_key_id 7 info:read invoices:read invoices:write offchain:read offchain:write
# copie o hex que ele imprime e depois:
echo "PASTE_THE_HEX_HERE" | xxd -r -p > mostro.macaroon   # apt install -y xxd se faltar

Ao contrário do Mostro, o lncli verifica se NODE_ADDRESS consta no certificado do nó. O LND inclui os endereços da própria máquina ao criá-lo, mas não, por exemplo, um endereço de VPN adicionado depois. Se a conexão falhar com um erro de certificado, rode o lncli no próprio nó, ou adicione o endereço com tlsextraip (ou tlsextradomain) no lnd.conf, apague tls.cert e tls.key e reinicie o LND para que ele crie um certificado novo; depois copie também o novo tls.cert para o Mostro.

Como o Mostro se conecta ao LND

O Mostro fala com a porta gRPC do LND (10009 por padrão) e se autentica com o tls.cert e o macaroon. Três coisas valem a pena saber antes de escolher onde o LND roda:

LND no mesmo VPS

Instale o LND seguindo o guia oficial (docs.lightning.engineering), usando os binários de release. O LND precisa de uma visão da cadeia Bitcoin, e essa escolha define o tamanho do seu VPS:

BackendDiscoCompromisso
bitcoind, nó completoMais de 700 GBO mais robusto. A sincronização inicial leva dias.
bitcoind, podadoDezenas de GBSuportado pelo LND e robusto; a sincronização inicial ainda leva dias.
neutrinoAlguns GBSem nó Bitcoin e com início rápido, mas depende dos pares com que sincroniza. Um nó neutrino que travou por cerca de 21 horas é o motivo de o Mostro agora vigiar a sincronização do LND (5.4). Se usá-lo, aponte-o para nós Bitcoin de sua confiança com neutrino.connect e configure os alertas de saúde.

Depois torne o LND acessível ao Mostro. Com a instalação nativa (Opção C) nada muda: use https://127.0.0.1:10009. Com Docker (Opções A e B) o container é um host separado, então escolha um:

LND em outro servidor ou em casa

Conecte as duas máquinas com uma VPN como WireGuard ou Tailscale, faça o LND escutar no endereço dele na VPN (rpclisten=VPN_IP:10009, e também rpclisten=localhost:10009 para o lncli continuar funcionando no nó: qualquer linha rpclisten substitui a padrão) e defina lnd_grpc_host = 'https://VPN_IP:10009'. Copie o tls.cert e o macaroon para o servidor do Mostro. Abrir a porta 10009 para a internet também funciona, mas aí o macaroon é a única coisa entre o mundo e o seu nó: evite. Um nó em casa precisa ficar online 24/7: uma queda de energia ou de conexão deixa as operações dos seus usuários esperando.

Nó-em-caixa (Start9, Umbrel, RaspiBlitz)

Esses sistemas instalam e atualizam o LND para você, geralmente num computador pequeno em casa. No StartOS o caminho mais simples é o próprio pacote Mostro, que se conecta ao serviço LND da mesma caixa. Usar o LND da caixa a partir de um Mostro num VPS é mais difícil: esses sistemas gerenciam a configuração do LND por conta própria, então talvez você não consiga adicionar uma linha rpclisten, e eles costumam expor o gRPC só na rede local ou via Tor, que o Mostro não consegue usar. Verifique o que o seu sistema permite antes de planejar assim. Cada sistema mostra os dados de conexão do LND na sua própria interface (no StartOS, nas propriedades do serviço LND); o lncli geralmente roda dentro do container do LND — no Umbrel, por exemplo, sudo docker exec -it lightning_lnd_1 lncli ... (confira o nome com sudo docker ps). Crie o macaroon em hexadecimal como mostrado acima.

Voltage (LND hospedado)

A Voltage roda o LND para você. Baixe o tls.cert e o macaroon de admin no painel do nó, use-os apenas para criar o macaroon restrito do Mostro a partir da sua própria máquina (veja acima) e aponte lnd_grpc_host para o endereço gRPC que o painel mostra, porta 10009. Você ainda fornece e gerencia a liquidez.

Configurações do LND que afetam o Mostro

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?

Volume de trading alvoLiquidez sugeridaBTC aproximado
Comunidade pequena (poucas operações/dia)1–5 milhões de sats0,01–0,05 BTC
Comunidade média5–20 milhões de sats0,05–0,20 BTC
Comunidade ativa20–100 milhões de sats0,20–1,0 BTC
💡 Nota sobre Liquidez Lightning

O Bitcoin nos seus canais Lightning está bloqueado onchain mas continua altamente utilizável via Lightning Network. Muitos serviços aceitam pagamentos Lightning — de cafeterias a provedores de VPS — tornando sua liquidez bastante flexível para uso cotidiano.

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:

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

⚠️ Importante

Nunca reutilize chaves Nostr entre instâncias de Mostro. Cada nó precisa de sua própria identidade única.

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

TarefaDificuldadeConhecimentos necessários
Alugar um VPSFácilCartão de crédito, navegação web básica
Conectar via SSHFácilSeguir instruções, digitar comandos
Instalar DockerMédioCopiar e colar comandos, resolução básica de problemas
Executar Mostro (Docker)MédioEditar arquivos de configuração, entender caminhos
Executar Mostro (nativo)DifícilAdministração Linux, compilação de software, systemd
Configurar LND do zeroDifícilConhecimento significativo de Linux e redes
Gerenciar liquidez LightningDifícilEntender a economia de canais Lightning

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

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

💡 Nota

Docker é necessário para as opções A e B. Se for compilar manualmente (Opção C), pode pular este passo.

# 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.20.2/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/mostro.macaroon ~/mostro-config/lnd/mostro.macaroon

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

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/mostro.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"  # o mostrod sempre usa <diretório-de-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

⚠️ Importante

Evite chmod 777. Use permissões mínimas.

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

Se o LND está no mesmo VPS (o LND precisa aceitar a conexão do container, ou use a rede do host: veja 2.2):

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

Se o LND está em um servidor diferente:

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

Passo 11: Verificar os logs

docker logs -f mostro

Procure estas mensagens:

💡 Nota

Não existe uma mensagem de "conectado ao LND" nem de "conectado ao relay". O Mostro contata o LND durante a inicialização, então um daemon que passa da inicialização já alcançou o LND. A falha, por outro lado, é ruidosa: registra Ln node error e encerra. Depois da inicialização ele consulta o LND a cada 15 segundos e registra LND did not answer GetInfo se ele parar de responder; os pagamentos de saída então esperam até ele voltar (5.4). Para os relays, a linha do evento de saúde é o seu sinal: No relay accepted the health event significa que nenhum deles o aceitou.

💡 Solução de problemas

Se aparecer Permission denied (os error 13), reaplique as permissões: chown -R 1000:1000 ~/mostro-config e reinicie: docker restart mostro.

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

Alternativa: Docker Compose

Em vez de um comando docker run longo, você pode descrever o contêiner em um arquivo compose. Ele roda a mesma imagem com as mesmas configurações, e atualizar vira trocar o tag em uma linha. Crie ~/mostro-docker/compose.yml:

mkdir -p ~/mostro-docker
nano ~/mostro-docker/compose.yml
services:
  mostro:
    image: mostrop2p/mostro:v0.20.2
    container_name: mostro
    restart: unless-stopped
    extra_hosts:
      - "host.docker.internal:host-gateway"  # só se o LND roda neste VPS
    volumes:
      - ${HOME}/mostro-config:/config

Suba e acompanhe os logs:

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

Escolha um: docker run ou compose, não os dois. Para atualizar qualquer um deles, veja 5.5.

🔒 Nota de Segurança

Use sempre uma tag de versão específica (ex: mostrop2p/mostro:v0.20.2) em vez de :latest para controlar os deployments.

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, com uma diferença: make docker-build copia o seu macaroon para config/lnd/admin.macaroon, seja qual for o nome original, então aponte o Mostro para lá:

lnd_macaroon_file = '/config/lnd/admin.macaroon'  # continua sendo o seu mostro.macaroon restrito, com outro nome
⚠️ Se o LND roda na mesma VPS

Diferente da Opção A, o docker/compose.yml do repositório não mapeia host.docker.internal, então no Linux esse nome não resolve dentro do container. Adicione o mapeamento ao serviço mostro antes de compilar:

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

Ou aponte lnd_grpc_host para o IP local do host. Note que make docker-build também compila a imagem StartOS, que uma VPS não precisa: custa apenas tempo de compilação.

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

# Inicia o Mostro e o relay incluído. `make docker-up` sozinho também
# inicia a imagem StartOS, que você não precisa numa VPS.
docker compose -f docker/compose.yml up -d mostro nostr-relay

# Verificar status
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
⚠️ Importante

NÃO instale Rust via apt install rustc. Sempre use rustup. O pacote do sistema geralmente está desatualizado.

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

Se a compilação falhar por falta de RAM, adicione espaço swap:

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 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
💡 O assistente interativo de configuração

Se você rodar o mostrod sem um settings.toml no diretório indicado e estiver num terminal, ele oferece um menu de configuração que pode montar o arquivo para você e escrever o nsec num .env. Sem terminal (Docker, systemd, CI) ele copia o template, imprime onde o deixou e encerra para você editar.

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

💡 Dica

Você também pode rodar seu próprio relay Nostr ao lado do Mostro. O caminho Docker Build (Opção B) inclui um no seu compose.yml; a Opção A e a compilação nativa não.

Manter a chave fora do settings.toml

O Mostro também lê a chave da variável de ambiente MOSTRO_NSEC_PRIVKEY. A precedência é: variável de ambiente, depois <diretório-de-config>/.env, depois settings.toml.

# ~/mostro-config/.env  (chmod 600) — carregado automaticamente na inicialização
MOSTRO_NSEC_PRIVKEY=nsec1...

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

# Unidade systemd
Environment="MOSTRO_NSEC_PRIVKEY=nsec1..."

Deixar nsec_privkey no settings.toml continua funcionando. Se usar o arquivo .env, faça backup dele com o mesmo cuidado da configuração.

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.

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.

📝 Nota

Definir dev_fee_percentage abaixo de 0.10 impedirá o Mostro de iniciar. Este mínimo garante financiamento sustentável do desenvolvimento.

4.3 Limites de ordens e moedas

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

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 não tomada fica no livro
max_expiration_days = 15     # Maior expiração que um criador pode pedir
expiration_seconds = 900     # Quanto tempo uma ordem tomada pode esperar pela hold invoice
                             # ou pela fatura do comprador antes de voltar ao livro (15 min)

[lightning]
hold_invoice_expiration_window = 300  # Tempo que o tomador tem para pagar a fatura ou fornecer uma de recebimento (5 min)
hold_invoice_cltv_delta = 144         # Duração do escrow, em blocos (~1 dia)

Note que hold_invoice_expiration_window pertence a [lightning]: escrito em [mostro] ele é ignorado em silêncio. Deve ser maior que 0 e também é a expiração da fatura da caução do tomador.

Quando os sats do vendedor estão travados, o comprador tem aproximadamente hold_invoice_cltv_delta - escrow_deadline_margin_blocks blocos para enviar o pagamento: 144 − 24 = 120 blocos, cerca de 20 horas, com os padrões. Quando esse prazo acaba, o Mostro cancela a operação se o comprador nunca marcou o pagamento como enviado, ou abre uma disputa se marcou (veja 4.9). Os usuários veem a contagem regressiva no app.

4.6 Anti-Spam

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

Um filtro mais fino é o pow_first_contact. pow se aplica a toda mensagem, enquanto pow_first_contact se aplica só a remetentes que não fazem parte de uma operação ativa e é verificado antes da decifragem. Assim as operações em curso seguem baratas e os desconhecidos precisam de trabalho real:

[mostro]
pow = 0                  # operações em curso
pow_first_contact = 16   # novas ordens e tomadas de chaves desconhecidas

Os clientes precisam minerar pelo menos esse tanto. Quem usa mostro-cli tem de definir POW (ou -p) com o seu valor; caso contrário, suas novas ordens e tomadas são descartadas sem resposta.

Um desestímulo mais forte contra quem toma ordens e some é a caução anti-abuso (veja 4.11).

4.7 Interface RPC de Administração (Opcional)

[rpc]
enabled = false
listen_address = "127.0.0.1"
port = 50051
# auth_token = "uma-string-longa-e-aleatoria"

Esta interface gRPC é para ferramentas do operador: grpcurl, e mostro-cli para o modo manutenção (admsetmaintenance, admmaintenancestatus, admcancelpending). O Mostrix não a usa: ele trabalha sobre Nostr, então você não precisa de RPC para resolver disputas.

⚠️ Segurança

Mantenha listen_address em "127.0.0.1" e nunca exponha a porta à internet. Configure auth_token sempre que a porta for alcançável por algo diferente da máquina local, como um túnel SSH ou um container sidecar: uma conexão encaminhada chega como loopback, então o endereço de escuta por si só não é autorização. Com um token configurado, toda chamada que modifica estado deve levar o header authorization: Bearer <token>.

Além do modo manutenção, o RPC traz as chamadas de reputação RevokeReputationImports e RebindReputationExport (veja 4.13). Ambas são aceitas apenas via loopback, e o mostro-cli ainda não tem comando para elas: use o grpcurl. O mostro-cli envia o MOSTRO_RPC_TOKEN apenas para um endereço loopback ou via https://, nunca em texto claro para um host remoto.

4.8 Protocolo de Transporte

Desde a v0.19.0 um nó Mostro fala apenas o protocolo v2: eventos kind 14 assinados com conteúdo cifrado NIP-44. O protocolo v1 (gift wraps NIP-59, kind 1059) foi removido, e não há mais nada para escolher. Deixe a linha transport fora do settings.toml; o template não a tem mais.

Linha no settings.tomlResultado
nenhumaProtocolo v2. Recomendado.
transport = "nip44"Protocolo v2. Aceita e inofensiva.
transport = "gift-wrap"O Mostro se recusa a iniciar, com um erro que manda você apagar a linha.

Seu nó anuncia protocol_version 2 no seu evento de info kind 38385. Todos os clientes atuais falam v2: o Mostro App, o Mostrix 0.3.1 ou posterior, o mostro-cli 0.16.2 ou posterior e o Bosstro. Um cliente que só fala v1, como uma versão antiga do Mostro Mobile, não recebe resposta do seu nó: peça aos seus usuários que atualizem.

⚠️ Atualizando da v0.18.x

Se o seu settings.toml ainda tem transport = "gift-wrap", apague essa linha antes de atualizar. A única forma de continuar atendendo clientes do protocolo v1 é ficar no mostrod 0.18.x, que já não recebe correções.

4.9 Limites de Segurança Lightning

Estas configurações de [lightning] limitam quanto tempo seus canais podem ficar travados e quantos pagamentos podem estar sem resolução ao mesmo tempo. Todas têm valor padrão, então um arquivo de configuração de uma versão anterior normalmente ainda inicia, mas um template novo já as inclui e vale conhecê-las.

[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
ConfiguraçãoO que protege
max_final_cltv_expiry_deltaRejeita uma fatura de recebimento cujo CLTV final permitiria ao beneficiário reter seus sats por muito tempo. 144 blocos (cerca de um dia) é o máximo que carteiras reais pedem. Nunca coloque 0: isso rejeita toda fatura.
escrow_deadline_margin_blocksMargem de segurança antes de o LND cancelar automaticamente uma hold invoice aceita. Quando a cadeia chega tão perto, o Mostro cancela a operação ou abre uma disputa enquanto o escrow ainda existe. Desde a v0.20.0 o Mostro se recusa a iniciar a menos que ela seja de pelo menos 18 (o invoices.holdexpirydelta padrão do LND, 12, mais 6 blocos de folga) e menor que hold_invoice_cltv_delta. Se você aumentou o holdexpirydelta, mantenha esta margem pelo menos 6 blocos acima dele por conta própria. O valor é publicado no seu evento de info.
max_inflight_payoutsTeto de pagamentos sem resolução no nó inteiro, para que um beneficiário que nunca liquida não esgote seus slots de HTLC. Um pagamento contido é atrasado, nunca descartado.
max_inflight_payouts_per_destinationO mesmo teto por pubkey de destino, e o mais eficaz dos dois.
payment_cltv_limitTeto do timelock total de uma rota de pagamento. Não deve exceder o --max-cltv-expiry do seu LND e deve ficar pelo menos 576 blocos acima de max_final_cltv_expiry_delta, ou pagamentos legítimos falham com "no route".
allow_node_changeGuarda de inicialização para troca de nó Lightning. Deixe em false e veja 5.8.

Note também que max_routing_fee, no bloco [mostro], agora tem padrão 0.002 (0,2%).

4.10 Fontes de Preço do Bitcoin

O Mostro precisa de uma taxa BTC/fiat para cotar as ordens. Sem um bloco [price] ele usa uma única fonte, a Yadio, através do já descontinuado bitcoin_price_api_url. Adicionar o bloco te dá várias fontes, combinadas por mediana e com descarte de valores atípicos, então uma API fora do ar ou devolvendo um número ruim não move seus preços.

[price]
update_interval_seconds = 300
max_price_staleness_seconds = 1800
outlier_threshold_pct = 5.0        # descarta uma fonte a essa distância da mediana (precisa de 3+ fontes)
provider_timeout_seconds = 10
provider_failure_threshold = 3     # falhas antes de deixar uma fonte de molho
provider_failure_cooldown_seconds = 120
publish_to_nostr = true            # publica as taxas agregadas como kind 30078

[price.providers.yadio]
enabled = true
url = "https://api.yadio.io"

[price.providers.coingecko]
enabled = true
url = "https://api.coingecko.com/api/v3"
# api_key = "CG-xxxx"              # opcional, aumenta os limites de taxa

[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"]            # só taxa oficial, não misturar com fontes informais

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

Cada fonte aceita only ou except para limitar a quais moedas contribui, e fallback_urls para espelhos tentados quando a URL principal falha. Uma fonte habilitada sem um segredo obrigatório falha na inicialização em vez de silenciosamente não produzir cotação alguma.

💡 Se as APIs de preço estão bloqueadas no seu país

Você pode pegar as taxas do Nostr em vez de HTTP, publicadas por nós Mostro em que você confia. Isso reaproveita os relays que já estão em [nostr], então funciona em qualquer lugar onde seu nó já alcance um relay. Com vários nós confiáveis, vence o evento válido mais recente.

[price.providers.nostr]
enabled = true
trusted_nodes = [
    # pubkeys hex de nós Mostro em que você confia para publicar taxas exatas
]

Operadores que atendem o peso cubano podem adicionar o El Toque para CUP e MLC do mercado informal. É opt-in, restrito a essas duas moedas, e precisa de um token gratuito: um El Toque habilitado sem token se recusa a iniciar.

Mantenha publish_to_nostr = true. Além de alimentar outros nós, as taxas publicadas dizem ao Mostro App quais moedas o seu nó consegue cotar a preço de mercado: um código ausente delas é oferecido apenas a preço fixo. Para cotar stablecoins e bitcoin em outras redes, veja 4.12.

⚠️ Adicionar qualquer bloco [price] troca o motor de preços

Assim que o settings.toml tem uma tabela [price] ou [price.providers.*], o Mostro usa o motor de várias fontes e ignora o bitcoin_price_api_url. Garanta que pelo menos uma fonte de mercado (Yadio, CoinGecko, Currency API, Blockchain.com…) esteja habilitada, ou seu nó fica sem taxa fiat e recusa toda ordem a preço de mercado. Observe no log de inicialização os avisos que começam com price:.

4.11 Outros Blocos Opcionais

Mais blocos que você pode encontrar num template recente. Nenhum é obrigatório. Três deles têm uma seção própria: [price.providers.pegged] (4.12), [reputation_import] / [reputation_export] (4.13) e [health] (5.4). O serbero_pubkey, em [mostro], é tratado em 5.10.

Retenção de eventos. Quanto tempo o Mostro guarda cada tipo de evento antes de expirar. Omita o bloco inteiro para aceitar os padrões.

[expiration]
order_days = 30        # eventos de ordens (kind 38383)
rating_days = 90       # histórico de reputação (kind 38384)
dispute_days = 90      # disputas, guardadas mais tempo para auditoria (kind 38386)
fee_audit_days = 365   # transparência de taxas (kind 8383)
dm_days = 30           # mensagens diretas do protocolo v2 (kind 14)

Cauções anti-abuso

[anti_abuse_bond] pede a tomadores, criadores ou ambos que travem uma pequena hold invoice Lightning junto à operação. Os usuários honestos a recebem de volta intacta; um solver pode confiscar a caução de quem agiu de má-fé, e uma parte vai para a contraparte honesta. Os usuários a veem como um "depósito" no app, e a documentação para usuários a explica no capítulo Anti-Abuse Bond. Todas as fases foram liberadas; vem desabilitada por padrão.

[anti_abuse_bond]
enabled = true
amount_pct = 0.01                 # caução = max(1% da ordem, base_amount_sats)
base_amount_sats = 1000
apply_to = "take"                 # "take" | "make" | "both"
slash_on_waiting_timeout = false  # confisca também de quem deixa sua etapa expirar
slash_node_share_pct = 0.5        # parte da caução confiscada que o nó fica
payout_claim_window_days = 15     # tempo que o vencedor tem para reivindicar sua parte
maker_bond_payment_timeout_seconds = 900
# bond_cltv_delta = 432           # veja abaixo

Leia o docs/ANTI_ABUSE_BOND.md do projeto antes de habilitá-lo num nó em produção, e avise seus usuários antes.

Histórico do pagador (experimental)

[payer_history] combate o golpe da triangulação, em que um comprador paga a partir da conta bancária de um terceiro. O comprador se compromete com um hash da conta de que vai pagar (declare-payer), o vendedor pode compará-lo com o remetente no seu extrato, e o Mostro guarda apenas um HMAC dele. Na v0.20.2 só a declaração está ligada: a exigência require_declaration e o histórico mostrado aos vendedores ainda não estão implementados, e nenhum cliente lançado envia declare-payer. Deixe desligado por enquanto.

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

Escrow com Cashu

[cashu] é um modo experimental que roda sem LND e mantém o escrow das operações em tokens Cashu. Ainda não serve para operar de verdade — as ações da operação depois da tomada continuam sendo rejeitadas — e não pode ser combinado com as cauções anti-abuso. Desde a v0.19.3 o criador escolhe a mint por ordem a partir de uma lista permitida:

# [cashu]
# enabled = false
# mint_urls = ["https://mint.example.com"]   # vazio [] = qualquer mint com host público
# escrow_locktime_days = 15

A antiga chave única mint_url é rejeitada: uma configuração que ainda a tenha não carrega.

4.12 Stablecoins e Bitcoin em Outras Redes

Desde a v0.20.2 um nó pode oferecer operações contra seis códigos que não são moedas fiat: stablecoins em dólar e bitcoin em outras redes. Os sats Lightning são sempre um dos lados da operação; o outro lado é pago on-chain, na Liquid, na Rootstock ou na rede da stablecoin, diretamente entre os dois usuários.

CódigoO que éCotado comoValor da ordem em
USDTTether USD1 USDmoedas inteiras
USDCUSD Coin1 USDmoedas inteiras
DOCDollar on Chain (Rootstock)1 USDmoedas inteiras
BTCBitcoin on-chain1 sat = 1 satsats
LBTCL-BTC na Liquid1 sat = 1 satsats
RBTCRBTC na Rootstock1 sat = 1 satsats

Habilitando

Você precisa do mostrod v0.20.2 ou posterior. Duas configurações trabalham juntas: fiat_currencies_accepted diz quais códigos as ordens podem usar, e o provedor pegged diz quais deles têm preço de mercado.

[mostro]
# Mantenha suas moedas fiat e adicione os novos códigos, em MAIÚSCULAS
fiat_currencies_accepted = ['USD', 'BRL', 'USDT', 'USDC', 'DOC', 'LBTC', 'RBTC']

# Uma fonte de preço de mercado para fiat (e portanto para as stablecoins).
# Obrigatória na v0.20.2 assim que você adiciona qualquer tabela [price.providers.*].
[price.providers.yadio]
enabled = true
url = "https://api.yadio.io"

[price.providers.pegged]
enabled = true
only = ["USDT", "USDC", "DOC", "LBTC", "RBTC"]   # ou except = ["BTC"]; sem nenhum dos dois, os seis

Reinicie o Mostro e confira o log. Se aparecer price: the pegged provider quotes ... but fiat_currencies_accepted does not list them, adicione os códigos que faltam: um código cotado que não é aceito publica uma taxa mas recusa toda ordem. Um fiat_currencies_accepted = [] vazio aceita todos os códigos.

⚠️ Não adicione o bloco pegged sozinho na v0.20.2

Qualquer tabela [price.providers.*] troca o nó para o motor de preços de várias fontes e descarta o legado bitcoin_price_api_url. Na v0.20.2 uma tabela pegged sem uma fonte de mercado ao lado deixa o nó sem taxas fiat: as ordens a preço de mercado em USD, EUR e USDT são todas recusadas. Habilite sempre pelo menos uma fonte de mercado, como no exemplo acima. (A próxima versão mantém automaticamente a fonte Yadio legada nesse caso.) Na v0.20.1 ou anterior, não adicione o bloco: o provedor não existe nelas.

Somente preço fixo. Para aceitar um código mas não cotá-lo a preço de mercado, liste-o em fiat_currencies_accepted e deixe-o fora de only. Os usuários então precisam definir um valor fixo em sats. É uma escolha sensata para o BTC on-chain, em que as taxas da rede tornam estranhas as ordens pequenas a preço de mercado.

O que seus usuários veem

O Mostro App 2.1.2 e posteriores mostra esses códigos no seletor de moeda, em Stablecoins e Bitcoin em outras redes, mas apenas os que o seu nó aceita. Os valores de BTC, LBTC e RBTC são digitados em sats. O método de pagamento nomeia a rede (USDT (Tron), USDC (Base), DOC (Rootstock), LBTC (Liquid)…), o vendedor compartilha um endereço de recebimento no chat da operação, e o comprador cola ali o ID da transação depois de pagar. O Mostro nunca verifica a rede nem o endereço. O mostro-cli e o Mostrix por enquanto só criam ordens de preço fixo nesses códigos.

As disputas precisam de outras provas

Instrua seus solvers antes de habilitar isto. Não há extrato bancário: a prova é o ID da transação colado no chat, que o solver confere num explorador de blocos dessa rede. Na Liquid o comprador deve compartilhar o link unblinded, porque a Liquid oculta os valores. As transferências são irreversíveis, um pagamento na rede errada pode ser perdido, e o comprador paga a taxa de rede: o vendedor deve receber o valor completo. O vendedor só deve liberar depois que a transferência confirmar. O prazo é o mesmo do fiat (cerca de 120 blocos com os padrões, veja 4.5), então uma transferência on-chain de taxa baixa pode perdê-lo.

💡 Se uma stablecoin perder a paridade

Ainda não existe uma proteção automática contra depeg. Se o USDT ou o USDC se afastar de um dólar, remova-o de only, ou adicione-o a except se não usar only (mantenha-o em fiat_currencies_accepted se ainda quiser ordens de preço fixo) e reinicie.

4.13 Importação e Exportação de Reputação

Os usuários podem trazer a reputação que ganharam em outro lugar — no bot do Telegram @lnp2pBot ou em outro nó Mostro — para o seu, de modo que um trader que se muda não comece do zero. Três valores viajam: o número de avaliações recebidas, a nota média e a data da primeira operação. Chegam como uma atestação: um pequeno evento Nostr (kind 38388) assinado pela fonte, endereçado à identidade do usuário e válido por 7 dias. Seu nó os soma à reputação do próprio usuário, e as contrapartes veem uma única cifra combinada.

Ambas as direções são opt-in e vêm desligadas por padrão. A importação exige o mostrod v0.20.0 ou posterior; a exportação, v0.20.1 ou posterior. Os usuários precisam do Mostro App em modo reputação: no modo de privacidade total não há identidade para carregar uma reputação.

Importando do lnp2pBot

O lnp2pBot assina as atestações com uma chave dedicada. Adicione-a à sua lista de confiança:

[reputation_import]
enabled = true
max_lifetime_seconds = 604800   # maior atestação que você aceita (7 dias; no máximo 30)

[[reputation_import.issuers]]
name = "lnp2pbot"               # nunca renomeie uma entrada que já tenha importações
keys = ["000004ac730537f1cf7d91f4f584a498a530a0205d35e816ebbaf23aec61e459"]
# npub1qqqqftrnq5mlrnmaj860tp9ynzjnpgpqt567s9hthter4mrpu3vsrta3em

Reinicie o Mostro. Seu evento de info (kind 38385) passa a levar uma tag reputation_import_issuers, que é como o app sabe que pode oferecer a importação no seu nó. Vários nós de comunidades já confiam nessa chave.

O bot exporta uma conta com pelo menos 10 operações concluídas e 5 avaliações recebidas que não esteja banida. O usuário começa pelo app (Configurações → Rede → Reputação → Importar reputação → Obter no lnp2pBot), confirma no Telegram que o npub coincide e cola de volta a mensagem que o bot envia.

Confiando em outro nó Mostro

Um nó que exporta anuncia sua chave de assinatura na tag reputation_issuer do seu evento de info. Leia-a com o comando de 5.4 (procure essa tag), confirme-a com o operador e adicione uma entrada para ele:

[[reputation_import.issuers]]
name = "mostro-example"         # um nome local estável à sua escolha
keys = ["<that node's reputation_issuer key, npub or hex>"]

Um usuário pode importar uma vez de cada fonte em cada nó, e a importação não pode ser desfeita pelo usuário. Os valores são uma fotografia: as avaliações posteriores na fonte não os acompanham.

Exportando do seu nó

A exportação permite que seus usuários levem a reputação que ganharam no seu nó para outro. Só viajam as avaliações recebidas no seu nó, nunca as importadas. O usuário precisa de 10 operações concluídas e 5 avaliações recebidas no seu nó, e não pode estar banido.

As atestações são assinadas com uma chave dedicada, nunca com a chave do seu nó. Gere uma e guarde-a junto ao nsec, no ambiente ou em <config-dir>/.env:

# Layout do Docker Hub; use o seu próprio diretório de configuração nos demais casos
echo "MOSTRO_REPUTATION_ISSUER_SK=$(openssl rand -hex 32)" >> ~/mostro-config/.env
sudo chown 1000:1000 ~/mostro-config/.env
chmod 600 ~/mostro-config/.env
[reputation_export]
enabled = true
issuer_key_env = "MOSTRO_REPUTATION_ISSUER_SK"
lifetime_seconds = 604800       # 1 a 604800 (7 dias)

O Mostro se recusa a iniciar se a variável estiver ausente ou for inválida, se contiver a chave do seu próprio nó, ou se sua chave pública também estiver na sua lista de [reputation_import]. Quando estiver rodando, seu evento de info passa a levar a tag reputation_issuer: compartilhe essa chave com os operadores que queiram confiar no seu nó. Faça backup da chave junto com seus outros segredos. Se ela vazar, qualquer pessoa pode emitir atestações em nome do seu nó até que os outros operadores a removam e revoguem as importações.

Revogando importações e reassociando exportações

Duas chamadas RPC de administração (4.7) tratam os casos raros. Elas são aceitas apenas via loopback; adicione -H 'authorization: Bearer <token>' se você definiu auth_token. Execute-as a partir de um checkout do repositório mostro, que contém o proto/admin.proto.

A chave de um emissor confiável vazou. Primeiro remova a chave da sua entrada e reinicie; depois reverta todas as importações assinadas com ela (adicione "imported_after": <unix time> para limitar às recentes):

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

Cada importação é revertida exatamente, as avaliações recebidas desde então são mantidas, e os usuários podem importar de novo com uma atestação da nova chave.

Um usuário perdeu a identidade à qual sua exportação está vinculada. A primeira exportação vincula a conta a uma identidade; movê-la normalmente exige uma autorização assinada com a identidade antiga, que o app produz. Se a identidade antiga se perdeu, você mesmo pode movê-la depois de verificar a pessoa:

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

Um usuário que restaura as mesmas 12 palavras mantém a mesma identidade e não precisa de nada disso.

5. Operando Seu Nó Mostro

5.1 Como funcionam as disputas

Disputas são sua responsabilidade operacional mais importante.

Quando ocorrem disputas?

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. Com as cauções anti-abuso habilitadas (4.11), o árbitro também pode confiscar a caução de quem agiu de má-fé.

O árbitro escreve a cada parte num chat privado da disputa, que o Mostro App mostra em Chat → Disputas. Qualquer uma das partes também pode compartilhar com o árbitro a chave do chat da sua operação, e então ele lê essa conversa na aba Observer do Mostrix ou no Bosstro. As partes ainda podem terminar a operação por conta própria: se o vendedor libera, ou se ambos concordam num cancelamento cooperativo, o Mostro encerra a disputa sozinho e avisa o árbitro.

Se você executa o Serbero (5.10), ele avisa seus árbitros no instante em que uma disputa abre e pode dar os primeiros passos com as partes. Nunca decide nem move fundos.

⚠️ Importante

Escolha seus árbitros com cuidado. Eles têm o poder de decidir para onde vão os fundos bloqueados. Escolha membros confiáveis e imparciais da comunidade. Recomenda-se 2-3 árbitros.

Níveis de permissão dos solvers

Um solver pode ser registrado como somente leitura ou com poderes completos. Os dois níveis podem assumir uma disputa e falar com as partes, mas só um solver read-write pode decidir para onde vai o dinheiro.

Registrado comoPodeNão pode
npub1...:readAssumir uma disputa, ler, escrever para ambas as partesLiquidar ou cancelar a ordem
npub1...:read-writeTudo, incluindo liquidar e cancelar—

Um npub1... sem sufixo fica como read-write por padrão, e o mesmo vale para o registro pela interface RPC. Comece um árbitro novo em :read enquanto ele aprende o processo, e registre-o de novo como read-write quando você confiar no julgamento dele. Um solver read-write pode assumir uma disputa que um solver somente leitura (ou o Serbero) esteja conduzindo.

Seus árbitros podem trabalhar num terminal com o Mostrix (5.2) ou num telefone Android com o Bosstro (5.11).

5.2 Mostrix — Sua ferramenta de administração

Mostrix é um cliente Mostro de terminal (TUI) com dois modos: um modo usuário para operar e um modo admin para resolver disputas — assumir disputas, conversar com as duas partes, liquidar ou cancelar, confiscar cauções e adicionar solvers. Se você executa um nó Mostro, precisa do Mostrix. Ele fala com o seu nó apenas via Nostr, nunca pela interface RPC.

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

# Linux (ARM64 / Raspberry Pi 4 e 5, SO de 64 bits)
wget https://github.com/MostroP2P/mostrix/releases/latest/download/mostrix-aarch64-unknown-linux-musl

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

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

# FreeBSD: mostrix-x86_64-unknown-freebsd
# Windows: baixe mostrix-x86_64-pc-windows-msvc.exe da página de releases

Verifique o download antes de executá-lo, como explicado logo abaixo.

🔐 Verifique a Release

Verifique sempre o binário antes de executá-lo. Importe as chaves dos mantenedores 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

As assinaturas são arquivos separados chamados manifest.txt.sig.<mantenedor>. As releases recentes trazem apenas manifest.txt.sig.arkanoider (chave 2E98 6CA1 C5E7 EA16 35CD 059C 4989 CC74 15A4 3AEC), então confira a página da release e baixe as que realmente estiverem listadas:

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

# Verifique cada assinatura que baixou
gpg --verify manifest.txt.sig.arkanoider manifest.txt

# Depois compare o hash do binário com o manifest
# (as linhas do manifest levam o prefixo artifact-<target>/, removido aqui)
sed 's#  artifact-[^/]*/#  #' manifest.txt | sha256sum -c --ignore-missing

Uma assinatura válida de uma chave de mantenedor em que você confia é suficiente. Se um wget retornar 404, essa assinatura simplesmente não foi publicada para essa release: não trate um arquivo ausente como um verificado.

Somente quando uma assinatura e o hash conferirem, dê permissão de execução ao binário e inicie-o:

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

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; o Mostrix precisa da 1.97 ou posterior)
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 o Mostrix cria o ~/.mostrix/ com um banco de dados que guarda uma nova seed de 12 palavras e um settings.toml, e então mostra um popup Backup New Keys com as 12 palavras. Anote-as. Um settings.toml colocado ao lado do binário tem precedência (modo portátil).

⚠️ Importante: aponte o Mostrix para o seu nó

A configuração gerada aponta para o nó público padrão do Mostro. Troque-o para o seu próprio nó: Settings → Select Mostro Instance e cole o npub ou hex do seu nó, ou edite mostro_pubkey em ~/.mostrix/settings.toml e reinicie.

Para o modo admin (resolução de disputas), as chaves relevantes são:

# ~/.mostrix/settings.toml
mostro_pubkey = "SUA_PUBKEY_MOSTRO"          # hex ou npub
nsec_privkey  = "nsec1..."                   # sua identidade de trader, derivada da seed — não edite
admin_privkey = "nsec1..."                   # a chave de um solver registrado — veja abaixo
relays = ["wss://relay.mostro.network"]
currencies_filter = []                       # vazio = mostrar todas as moedas
user_mode = "admin"                          # ou Settings → Switch Mode
# trusted_dm_senders = ["npub1..."]          # npub do Serbero, para ver seus relatórios (5.10)
⚠️ Qual chave vai em admin_privkey?

O Mostro aceita ações de disputa da sua própria chave (o nsec_privkey do daemon) e de chaves de solvers registrados. Qualquer outra chave é rejeitada. Só a chave do daemon pode adicionar solvers, então use-a apenas para isso e mantenha-a no servidor. Para o trabalho diário com disputas, registre uma chave de solver — read-write para liquidar ou cancelar — e coloque essa em admin_privkey. Nunca reutilize o nsec_privkey.

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

A opção Settings → Add Dispute Solver do Mostrix faz o mesmo, com Esquerda/Direita para escolher Read ou Read-Write (padrão Read-Write).

O modo admin na prática

5.3 mostro-watchdog — Alertas no Telegram para disputas e saúde do nó

mostro-watchdog é um bot do Telegram para a sua equipe de administração. Ele observa seu nó via Nostr e publica num grupo ou canal privado:

Opção A: script de instalação (recomendada). Ele baixa a última release, confere-a com o manifest.txt e instala em /usr/local/bin:

curl -fsSL https://raw.githubusercontent.com/MostroP2P/mostro-watchdog/main/install.sh | bash
# ou em outro diretório:
curl -fsSL https://raw.githubusercontent.com/MostroP2P/mostro-watchdog/main/install.sh | bash -s -- --install-dir ~/.local/bin

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

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

Os binários para macOS e Windows também estão na página de releases.

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

sudo apt install -y cmake pkg-config libssl-dev
git clone https://github.com/MostroP2P/mostro-watchdog.git
cd mostro-watchdog
cargo build --release
sudo cp target/release/mostro-watchdog /usr/local/bin/

Configuração

O watchdog guarda seu estado (disputes.db) ao lado do config.toml, então dê a ele um diretório só dele:

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

[nostr]
# Relays de bootstrap: o watchdog lê a lista de relays do seu nó (NIP-65)
# neles e depois segue os relays que o seu nó anuncia.
relays = ["wss://relay.mostro.network", "wss://nos.lol"]

[telegram]
bot_token = "SEU_BOT_TOKEN"           # do @BotFather
chat_id = -1001234567890              # seu grupo ou canal de administração

[health]
info_silence_threshold = 900          # 3 × o publish_mostro_info_interval do Mostro (300 por padrão)
mostro_health_enabled = true          # exige Mostro v0.20.0+
event_alert_threshold = 0             # veja abaixo

Para achar o chat_id, adicione o bot ao grupo, envie uma mensagem ali e abra https://api.telegram.org/bot<TOKEN>/getUpdates.

O antigo alerta de "silêncio de eventos" dispara sempre que nenhum evento de disputa chega por duas horas, o que na maioria dos nós é só uma tarde tranquila. As verificações de info e de saúde detectam um nó parado de forma confiável, então 0 o desliga.

A chave Nostr do watchdog

Os detalhes de saúde, os alertas do Serbero, os avisos aos solvers e o próprio heartbeat do watchdog precisam de uma chave só dele, passada apenas pelo ambiente:

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

Faça backup desse arquivo. Na inicialização o watchdog registra sua chave pública. Coloque-a no settings.toml do Mostro e reinicie o Mostro, para que sua liquidez, falhas de pagamento e expiração de HTLC sejam cifradas só para o watchdog:

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

Isso adiciona uma tag pública p ao seu evento de saúde que vincula o seu nó à chave do watchdog. Sem ela, o watchdog ainda alerta sobre o status público.

Executar como serviço

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

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

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

Opcional: Serbero e alertas aos solvers

Adicione uma seção vazia para cada um que quiser. Ambos usam a chave acima:

[serbero]                 # passos do Serbero na mensagem de cada disputa
[solver_notifications]    # avisos privados aos solvers

Para o Serbero, adicione também a chave pública hex do watchdog ao config.toml do Serbero como observador — nunca como solver — e reinicie o Serbero. Os observadores recebem uma linha por passo, nunca o que as partes escreveram. O watchdog encontra o Serbero sozinho através do serbero_pubkey do seu nó (5.10).

[[observers]]
pubkey = "WATCHDOG_PUBKEY_HEX"

Para os avisos aos solvers, cada solver envia /link ao bot num chat privado e digita o código no Mostrix 0.3.6 ou posterior, em Settings → Link Watchdog. O bot responde a comandos apenas em chats privados: /version, /link, /unlink, /status.

💡 Vigie o watchdog

Um canal silencioso não prova que o watchdog está vivo. Você pode executar um segundo em outra máquina, cada um com a sua própria WATCHDOG_NOSTR_PRIVATE_KEY e a chave pública do outro em [health].peer_watchdogs. Os alertas de saúde também podem ir para um chat próprio com [health].alerts_chat_id. O config.example.toml do projeto documenta todas as opções.

5.4 Monitoramento e saúde do nó

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

Rodar não é o mesmo que funcionar

Em outubro de 2026 o LND de um nó em produção deixou de acompanhar a cadeia por cerca de 21 horas. O Mostro continuou rodando e aceitando operações, mas todo pagamento a compradores falhava. Uma verificação de processo, de porta ou um robô de uptime teriam mostrado verde o tempo todo.

Desde a v0.20.0 o Mostro verifica isso por conta própria. A cada minuto ele publica um evento de saúde assinado (kind 38389) com um status geral (ok, degraded ou down), um estado para cada verificação (lnd_sync, payouts, relays, database) e a altura de blocos do LND. Vem ativado por padrão; este bloco apenas mostra os padrões:

[health]
enabled = true                  # publica o evento de saúde (kind 38389)
interval = 60                   # segundos entre publicações, de 30 a 3600
watchdog_pubkey = ""            # a chave do seu watchdog: as métricas detalhadas são cifradas para ela (5.3)
lnd_unsynced_fail_after = 600   # deve ser maior que 60
auto_maintenance_on_lnd_unsynced = true
lnd_resynced_clear_after = 300

Quando o LND deixa de estar sincronizado, o Mostro protege seus usuários por conta própria:

O log conta a história: LND reports synced_to_chain = false ...; outgoing payments wait after 60s, depois maintenance mode ON (reason lnd_unsynced), e mais tarde LND is synced to chain again e maintenance mode OFF. Verifique o LND com lncli getinfo (synced_to_chain, block_height). Defina auto_maintenance_on_lnd_unsynced = false para desativar a manutenção automática.

O Mostro só sabe o que o seu próprio LND lhe diz, e um nó preso numa cadeia antiga nem sempre sabe disso. Por isso os dois leitores abaixo comparam a altura de blocos dele com exploradores públicos:

A página de status pública

A página (Semáforo) lê os eventos de saúde direto dos relays e os verifica no navegador do visitante, sem backend. Cada nó recebe uma cor:

CorQuando
🟢 OperacionalStatus ok, um evento recente e o LND a menos de 3 blocos de atraso em relação aos exploradores
🟡 DegradadoStatus degraded, modo manutenção, ou nenhuma altura de blocos independente para comparar
🔴 Fora do arStatus down, LND 3 ou mais blocos atrasado, ou nenhum evento válido recente ("Not reporting")
⚪ Não monitoradoListado, mas ainda não se espera que publique

Sob cada nó, 90 barras diárias e um valor de uptime vêm de amostras coletadas a cada 10 minutos.

Como listar seu nó. Só são mostrados nós selecionados, porque qualquer pessoa pode assinar um evento sempre verde:

  1. Seu nó está listado como comunidade neste site.
  2. Ele roda o Mostro v0.20.0 ou posterior com o evento de saúde ativado, e publica em pelo menos um de wss://relay.mostro.network, wss://mostro-p2p.tech ou wss://relay.shadowbip.com.
  3. Abra uma issue ou pull request no MostroP2P/semaforo para adicioná-lo ao trusted.json com sua pubkey hex, nome, região e rede. Seu avatar é copiado da foto de perfil do seu Nostr.

Checar seu nó de fora

Seu nó republica um evento de info (kind 38385) que se descreve: taxas, moedas, versão de protocolo, flag de manutenção, configurações de caução, chaves do Serbero e de reputação. Ler isso e o evento de saúde de um relay é o jeito mais rápido de confirmar que o mundo externo vê o que você acha que vê.

cargo install nostreq nostcat
# Evento de info
nostreq --kinds 38385 --limit 1 --authors SUA_MOSTRO_PUBKEY_HEX \
  | nostcat --stream wss://relay.mostro.network | jq
# Evento de saúde: status, verificações, altura de blocos do LND
nostreq --kinds 38389 --limit 1 --authors SUA_MOSTRO_PUBKEY_HEX \
  | nostcat --stream wss://relay.mostro.network | jq '.tags'
💡 As verificações do host continuam úteis

Um ping ao host (UptimeRobot ou similar) continua avisando quando a própria VPS está inalcançável. Ele não diz se o Mostro está pagando os compradores; o evento de saúde diz.

5.5 Atualizando Mostro

Atualizar substitui o binário mostrod e nada mais: settings.toml e mostro.db ficam onde estão. As migrações do banco de dados rodam sozinhas quando a nova versão inicia, então não há passo extra.

Antes de atualizar

  1. Leia as notas da versão para a qual você vai. Seu settings.toml nunca é sobrescrito: compare-o com o novo settings.tpl.toml. A maioria dos recursos novos fica desligada até você adicioná-los, mas um bloco ausente assume seus padrões, e alguns padrões são ligados (o evento de saúde de 5.4, por exemplo).
  2. Faça backup do banco de dados com os comandos de 5.6. Você precisa desse backup para voltar atrás.
⚠️ Vindo da v0.18.x

Confira isto antes de iniciar a nova versão, ou ela pode se recusar a iniciar:

  • Apague qualquer linha transport = "gift-wrap" (4.8). Os usuários de clientes antigos do protocolo v1 precisam atualizar.
  • escrow_deadline_margin_blocks deve ser de pelo menos 18 e menor que hold_invoice_cltv_delta (4.9).
  • Em [cashu], mint_url passou a ser mint_urls = [...] (4.11).
  • Com as cauções anti-abuso ligadas e hold_invoice_cltv_delta de 288 ou mais, defina bond_cltv_delta explicitamente (4.11).
  • Desde a v0.20.0 o evento de saúde é publicado por padrão, e o Mostro pode entrar em manutenção por conta própria quando o LND está fora de sincronia (5.4).

Docker Hub (docker run)

export MOSTRO_TAG=v0.20.2
# Baixe primeiro: o nó continua no ar durante o 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

Use as mesmas flags da instalação (remova --add-host se o LND está em outro servidor). Se não lembrar delas, consulte docker inspect mostro antes de remover o contêiner.

⚠️ docker restart não é uma atualização

docker restart reinicia o mesmo contêiner, com a imagem com que foi criado. Para rodar uma versão nova o contêiner precisa ser criado de novo: docker rm + docker run, ou docker compose up -d depois de trocar o tag.

Docker Hub (Docker Compose)

export MOSTRO_TAG=v0.20.2
COMPOSE=~/mostro-docker/compose.yml
# Aponte a linha image para o novo tag e confira
sed -i "s|image: mostrop2p/mostro:.*|image: mostrop2p/mostro:$MOSTRO_TAG|" $COMPOSE
grep image: $COMPOSE
docker compose -f $COMPOSE pull
# Recria o contêiner porque a imagem mudou
docker compose -f $COMPOSE up -d

Docker Build

cd /opt/mostro
git fetch --tags
git checkout v0.20.2
make docker-build
make docker-down
make docker-up

Nativo

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

Verificar a nova versão

# 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

Procure as mesmas mensagens de inicialização da primeira execução (Passo 11 da Opção A).

Voltar à versão anterior

Se a nova versão der problemas, volte ao tag anterior. A nova versão pode já ter migrado o banco de dados, e um mostrod mais antigo pode se recusar a iniciar com ele, então restaure o backup feito antes de atualizar:

docker stop mostro
docker rm mostro
# troque YYYYMMDD pela data do backup feito antes de atualizar
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
# depois inicie o tag anterior: mesmo comando docker run,
# ou volte o tag antigo no compose.yml e rode docker compose up -d

Docker Build e nativo funcionam igual: faça checkout do tag anterior, recompile e restaure o banco de dados antes de iniciar.

⚠️ Não troque de nó Lightning ao mesmo tempo

Atualizar o Mostro é seguro a qualquer momento. Apontá-lo para um nó Lightning diferente não é: drene o escrow primeiro, veja 5.8.

5.6 Backups

Arquivos críticos para backup: settings.toml, o arquivo .env se você guarda seu nsec ali (veja 4.1) ou a chave de exportação de reputação (4.13), e mostro.db (histórico de ordens, reputação). Se você habilitar o histórico do pagador (4.11), mantenha os backups do banco separados do nsec: o histórico é indexado por ele.

⚠️ Não copie um banco em uso com cp

O SQLite roda em modo WAL, então as escritas recentes ficam em mostro.db-wal até serem consolidadas. Copiar só o mostro.db com o Mostro rodando pode gerar um backup sem as operações mais novas. Use o comando de backup do próprio SQLite, que é seguro num banco em uso e escreve um único arquivo consistente.

# Backup manual — Docker Hub:
mkdir -p /root/mostro-backups
sqlite3 ~/mostro-config/mostro.db ".backup '/root/mostro-backups/mostro.db.$(date +%Y%m%d)'"
cp ~/mostro-config/settings.toml /root/mostro-backups/settings.toml.$(date +%Y%m%d)
cp ~/mostro-config/.env /root/mostro-backups/env.$(date +%Y%m%d) 2>/dev/null

# Backup manual — Docker Build (Opção B):
sqlite3 /opt/mostro/docker/config/mostro.db ".backup '/root/mostro-backups/mostro.db.$(date +%Y%m%d)'"
cp /opt/mostro/docker/config/settings.toml /root/mostro-backups/settings.toml.$(date +%Y%m%d)
cp /opt/mostro/docker/config/.env /root/mostro-backups/env.$(date +%Y%m%d) 2>/dev/null

# Backup manual — Nativo:
sqlite3 /opt/mostro/mostro.db ".backup '/root/mostro-backups/mostro.db.$(date +%Y%m%d)'"
cp /opt/mostro/settings.toml /root/mostro-backups/settings.toml.$(date +%Y%m%d)
cp /opt/mostro/.env /root/mostro-backups/env.$(date +%Y%m%d) 2>/dev/null

Backup diário automático (adicione ao crontab com crontab -e):

# Docker Hub (Opção A):
0 3 * * * mkdir -p /root/mostro-backups && sqlite3 /root/mostro-config/mostro.db ".backup '/root/mostro-backups/mostro.db.$(date +\%Y\%m\%d)'" && cp /root/mostro-config/settings.toml /root/mostro-backups/settings.toml.$(date +\%Y\%m\%d); cp /root/mostro-config/.env /root/mostro-backups/env.$(date +\%Y\%m\%d) 2>/dev/null

# Docker Build (Opção B):
0 3 * * * mkdir -p /root/mostro-backups && sqlite3 /opt/mostro/docker/config/mostro.db ".backup '/root/mostro-backups/mostro.db.$(date +\%Y\%m\%d)'" && cp /opt/mostro/docker/config/settings.toml /root/mostro-backups/settings.toml.$(date +\%Y\%m\%d); cp /opt/mostro/docker/config/.env /root/mostro-backups/env.$(date +\%Y\%m\%d) 2>/dev/null

# Nativo (Opção C):
0 3 * * * mkdir -p /root/mostro-backups && sqlite3 /opt/mostro/mostro.db ".backup '/root/mostro-backups/mostro.db.$(date +\%Y\%m\%d)'" && cp /opt/mostro/settings.toml /root/mostro-backups/settings.toml.$(date +\%Y\%m\%d); cp /opt/mostro/.env /root/mostro-backups/env.$(date +\%Y\%m\%d) 2>/dev/null
⚠️ Crítico

Sua nsec_privkey no settings.toml É a identidade do seu nó. Se perdê-la, perde sua reputação e todos os usuários devem reconectar-se a uma nova identidade. Guarde uma cópia offline.

Se você roda o seu próprio LND

Os backups do Mostro não cobrem o seu nó Lightning. Os fundos nos seus canais dependem de dois backups do LND:

Nunca faça backup nem restaure o channel.db como forma de recuperar canais: uma cópia desatualizada faz o seu nó transmitir estados antigos, e os pares podem levar todos os fundos desses canais. Sistemas nó-em-caixa e a Voltage têm seus próprios recursos de backup; ative-os. A documentação do LND cobre a recuperação em detalhes (planejamento de recuperação).

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 de taxas: orders.fee guarda a metade de cada parte, então a taxa bruta do nó é fee*2 e a dev fee é descontada dela
sqlite3 /caminho/para/mostro.db "SELECT SUM(fee*2) AS gross_fees, SUM(dev_fee) AS dev_fees, SUM(fee*2 - COALESCE(dev_fee, 0)) AS net_fees FROM orders WHERE status = 'success';"

5.8 Modo Manutenção e Troca de Nó Lightning

Hold invoices, cauções e pagamentos em voo pertencem ao nó Lightning que os criou. Apontar o Mostro para outro nó enquanto algo disso está aberto deixaria essas operações penduradas, então o daemon se recusa a iniciar quando vê uma identidade LND nova com escrow ainda ligado à anterior:

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

O modo manutenção é a forma de drenar primeiro. Enquanto está ativo, novas ordens e tomadas são rejeitadas e as operações abertas continuam funcionando, para que o escrow possa liquidar. Requer a interface RPC habilitada (veja 4.7), e a chamada é aceita apenas via loopback: execute-a no host do nó, ou através de ssh -N -L 50051:127.0.0.1:50051 user@node.

O Mostro também pode entrar em manutenção por conta própria, com o motivo lnd_unsynced, quando o LND sai de sincronia (5.4). Se você ativar a manutenção enquanto isso estiver acontecendo, ela passa a ser sua e o daemon não a desfará; você não pode usar lnd_unsynced como motivo próprio.

  1. Anuncie a janela aos seus usuários com bastante antecedência.
  2. Ative o modo manutenção: mostro-cli admsetmaintenance -e true -r "LN node migration".
  3. Consulte mostro-cli admmaintenancestatus até reportar drained = true. Ordens pendentes expiram sozinhas; para encurtar a drenagem você pode cancelar uma com mostro-cli admcancelpending -o <order-id>, que libera a caução do criador na hora. Anuncie antes, é a ordem do usuário. Feche as disputas de longa duração como sempre.
  4. Mantenha o nó antigo online todo o tempo. Ele ainda tem que terminar os pagamentos em voo.
  5. Pare o Mostro e faça backup de mostro.db.
  6. Aponte [lightning] para o nó novo e deixe allow_node_change = false.
  7. Inicie o Mostro. Ele registra a pubkey nova. Desative o modo manutenção e teste com uma ordem.
  8. Só então desative o nó antigo.
⚠️ allow_node_change

Coloque true apenas para recuperação de desastre, quando o nó antigo se perdeu de vez. Isso deixa deliberadamente as operações afetadas sem resolução. Mover o mesmo nó para outro host não é troca de nó e não precisa de nada disso.

5.9 Comandos de Operador com mostro-cli

O Mostrix é o jeito confortável de trabalhar disputas, e o mostro-cli cobre o básico de um shell, além de alguns comandos de operador que o Mostrix não tem. Os comandos de disputa são assinados com uma chave Nostr passada como ADMIN_NSEC, e ela precisa ser a do próprio daemon ou a de um solver registrado. O CLI não lê nenhum arquivo de configuração: defina seu nó e os relays no ambiente, e coloque as flags globais antes do subcomando.

# Trabalho de disputas (via Nostr)
export MOSTRO_PUBKEY=npub1...            # seu nó
export RELAYS=wss://relay.mostro.network
export ADMIN_NSEC=nsec1...
mostro-cli listdisputes
mostro-cli admtakedispute -d <dispute-id>     # imprime as pubkeys do comprador e do vendedor
mostro-cli getadmindm -s 120
mostro-cli admsenddm -p <party-pubkey> -m "mensagem para uma parte"
mostro-cli admsettle -o <order-id> [--slashseller] [--slashbuyer]   # liberar para o comprador
mostro-cli admcancel -o <order-id> [--slashseller] [--slashbuyer]   # reembolsar o vendedor

# Registrar um árbitro, opcionalmente somente leitura
mostro-cli admaddsolver -n npub1...:read

As flags de confisco só importam com as cauções anti-abuso (4.11). Note a grafia: --slashseller, não --slash-seller. O admsenddm envia uma mensagem direta a partir da chave de admin; não é o chat por disputa que o Mostro App, o Mostrix e o Bosstro usam, então prefira esses clientes para falar com as partes.

Outro grupo de comandos vai pelo gRPC de administração em vez do Nostr, então precisam da interface RPC habilitada (veja 4.7) em vez de ADMIN_NSEC. O MOSTRO_RPC_URL tem como padrão http://127.0.0.1:50051, e o MOSTRO_RPC_TOKEN só é necessário se você definiu auth_token.

export MOSTRO_RPC_URL=http://127.0.0.1:50051
export MOSTRO_RPC_TOKEN=seu-token-de-auth

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

Vale conhecer o admcancelpending fora de uma migração. Ele cancela uma ordem que ainda está pendente ou esperando uma caução, avisa o criador e libera todas as cauções de uma vez. Use para uma ordem claramente abandonada ou mal cotada, e avise o criador antes: é a ordem dele, e isso não é uma resolução de disputa.

O mostro-cli ainda não tem comandos para importação e exportação de reputação, histórico do pagador nem para o evento de saúde: use o grpcurl para as RPCs de reputação (4.13) e os comandos de 5.4 para o evento de saúde. Instale-o com cargo install mostro-cli (Rust 1.97 ou posterior) ou pegue um binário em suas releases; execute mostro-cli <command> --help para ver todas as flags.

5.10 Serbero — Assistente de disputas

O Serbero é um assistente opcional para as disputas do seu nó. Você o executa ao lado do Mostro, com uma chave Nostr própria. Ele faz dois trabalhos:

O Serbero nunca move fundos e nunca decide uma disputa. O Mostro o registra como um solver somente leitura, então ele não pode liquidar nem cancelar, e qualquer solver read-write pode tomar uma disputa dele a qualquer momento. Se o Serbero cair, o Mostro e seus solvers funcionam exatamente como antes. Mantenha pelo menos um solver humano read-write.

Instalar

Cada release tem binários para Linux (x86_64, aarch64) e macOS (Apple silicon), cada um com um arquivo SHA-256. Os nomes dos arquivos levam a versão:

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

Com o Rust instalado, cargo install serbero --locked também funciona. Uma imagem Docker (ghcr.io/mostrop2p/serbero) e um arquivo compose estão descritos no README do projeto.

Configurar

cp config.sample.toml config.toml
nano config.toml
[serbero]
private_key_env = "SERBERO_PRIVATE_KEY"   # nomeia o segredo; a chave nunca vai neste arquivo
db_path = "serbero.db"

[mostro]
pubkey = "YOUR_MOSTRO_PUBKEY_HEX"
relays = ["wss://relay.mostro.network", "wss://nos.lol"]   # relays em que o seu nó publica

# Uma entrada por solver humano: a pubkey hex da chave que o cliente dele usa
# (Mostrix: admin_privkey). Nunca liste a chave do próprio Serbero.
[[solvers]]
pubkey = "SOLVER_PUBKEY_HEX"
permission = "write"

[notify]
renotify_after = "15m"

[mediation]
enabled = false

Executar como serviço

O projeto traz uma unit systemd reforçada. Baixe-a do main: a cópia dentro do arquivo da v0.2.5 precisa do systemd 251 e não inicia no Ubuntu 22.04.

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

Faça backup de /etc/serbero/credentials/serbero_private_key offline. É a identidade do Serbero: se a perder, você precisa registrar um npub novo.

Registrá-lo no seu nó

O Mostro v0.19.1 ou posterior registra o Serbero para você. Adicione o npub dele ao bloco [mostro] do seu settings.toml e reinicie o Mostro:

[mostro]
serbero_pubkey = "npub1..."   # a chave do Serbero, npub ou hex

Na inicialização o Mostro registra essa chave como solver somente leitura e a anuncia no seu evento de info. Esse anúncio é como o Mostro App rotula as mensagens do Serbero e como o mostro-watchdog o encontra. O log confirma: Serbero npub1... configured: registered as a read-only solver.

⚠️ Não adicione o Serbero com admaddsolver

Um npub simples adicionado com admaddsolver vira read-write (5.1), e então o Mostro se recusa a iniciar com REFUSING TO START: serbero_pubkey ... is a solver with write permission. Ele também recusa uma chave que pertença a um usuário que não é solver, e a chave do próprio nó. Dê ao Serbero uma chave só dele e deixe o serbero_pubkey registrá-la.

Seus solvers leem o Serbero no Mostrix

O Mostrix 0.3.5 ou posterior mostra as mensagens do Serbero num painel SERBERO em cada disputa, mas apenas de remetentes em quem o solver confia. No ~/.mostrix/settings.toml de cada solver:

trusted_dm_senders = ["npub1..."]   # o npub do Serbero

A pubkey do admin_privkey do solver deve ser exatamente a de uma entrada [[solvers]], e o Mostrix deve ler pelo menos um dos relays do Serbero. Para tomar um caso, pressione Ctrl+T sobre uma entrega; exige permissão read-write, e o Serbero para de escrever na hora. O Bosstro (5.11) ainda não mostra os resumos do Serbero.

Ativando a mediação (piloto)

A mediação vem desligada. Quando ligada, o Serbero assume cada nova disputa e se apresenta a ambas as partes como um assistente automatizado, no idioma delas (inglês, espanhol ou português), uma pergunta curta por vez. Quando ambos responderam, dá a eles 30 minutos para resolver a operação por conta própria e então entrega o caso aos seus solvers. Nunca diz a ninguém que libere ou cancele.

Para ler as respostas, o Serbero consulta um modelo juiz (o Jev, da TypeSafe) na sua própria conta paga. O juiz recebe os papéis da operação, o valor, a moeda e o método de pagamento, e o texto das mensagens — nunca as chaves públicas. Peça ao provedor retenção zero de dados e avise seus usuários de que as mensagens da disputa são processadas por um serviço automatizado. O README explica a chave de API e a tabela de limiares; defina enabled = true em [mediation] e reinicie, e o log diz mediation ready ou por que não.

As mensagens das partes são eventos kind 14: use mais de um relay, e apenas relays que as guardem, ou as mensagens enviadas enquanto o Serbero está offline se perdem. Para publicar o progresso do Serbero no Telegram da sua equipe, registre o mostro-watchdog como observador (5.3). Faça backup do serbero.db de forma privada: ele guarda as conversas das disputas.

5.11 Bosstro — Resolvendo disputas pelo celular

O Bosstro é o app Android para solvers de disputas. Ele leva o lado admin do Mostrix para um telefone: o solver vê as disputas pendentes do seu nó, assume uma, conversa com o comprador e o vendedor (imagens e PDFs incluídos), lê o chat das próprias partes quando uma delas compartilha sua chave e, com permissão read-write, paga o comprador ou reembolsa o vendedor, com a opção de caução quando o seu nó tem cauções.

É uma ferramenta para os seus solvers, não para operar, e nunca guarda a chave do seu nó. Registrar solvers continua sendo feito no Mostrix ou no mostro-cli (5.2).

Instalar e verificar

Android 7.0 ou posterior. Baixe o APK em GitHub Releases: arm64-v8a para quase qualquer telefone, armeabi-v7a para um antigo de 32 bits. Confira-o com o arquivo de checksums da release:

sha256sum -c SHA256SUMS.txt --ignore-missing

O checksum só prova que o download está completo. O certificado de assinatura prova quem o compilou, e o Android recusa uma atualização assinada com qualquer outra chave. Compare-o com o AppVerifier:

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

Adicionar um solver

  1. O solver abre o Bosstro, toca em Create new account (ou Log in com um nsec de solver existente) e envia a você o npub. Essa chave não deve ser usada para mais nada — nunca a chave de um app de trading, ou os dois papéis ficam vinculados publicamente.
  2. Você a registra, somente leitura para começar (5.1):
    ADMIN_NSEC=nsec1... mostro-cli admaddsolver -n npub1solver...:read
  3. O solver escolhe o seu nó no Bosstro: o Mostro, uma comunidade da lista, ou a sua própria pubkey e relays. O Bosstro descobre pelas respostas do seu nó se a chave é de um solver e com qual permissão.
⚠️ Limites atuais

O Bosstro fala apenas o protocolo v2 (4.8). A versão 0.1 não mostra os resumos de entrega do Serbero e ainda não tem notificações push, então os solvers que trabalham com o Serbero ainda precisam do Mostrix para isso. Um solver read-write pode tomar uma disputa do Serbero no Bosstro.

6. Análise de Custos

Custos operacionais mensais

ItemCusto mensalNotas
VPS (servidor)$10–24Depende do provedor e especificações
Nome de domínio (opcional)$1–2Para um site/identidade
Taxas on-chain de canais LightningVariávelAbertura/fechamento de canais
Total mensal$11–26Excluindo liquidez Lightning

Custos únicos / de capital

ItemCustoNotas
Liquidez Lightning0,01–1,0+ BTCBloqueado em canais; recuperado ao fechar
Hardware do nó (se auto-hospedado)$0–600Grátis se usar VPS; $300-600 para Start9/Umbrel
Tempo de configuração4–16 horasDependendo do nível de experiência

Potencial de receita

Volume mensalTaxa (0,6%)Taxa dev (30%)Sua receita líquida
$1.000~$6~$1,80~$4,20
$10.000~$60~$18~$42
$50.000~$300~$90~$210
$100.000~$600~$180~$420
📝 Realidade

A maioria dos nós novos leva meses para construir volume de operações. Não espere lucratividade imediata. O valor real geralmente vem de fornecer um serviço à sua comunidade, com as taxas como bônus.

Compromisso de tempo

TarefaFrequênciaTempo
Monitoramento (verificar logs, status)Diário5–10 min
Resolução de disputasConforme necessário15–60 min por disputa
AtualizaçõesMensal15–30 min
Gerenciamento de liquidezSemanal15–30 min
Estimativa semanal total1–3 horas

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?

Muita gente roda o LND num Raspberry Pi 4 ou 5 com SSD, pelo Start9, Umbrel ou RaspiBlitz, e o pacote Mostro do StartOS pode rodar ao lado dele. Para um nó do qual a sua comunidade depende, um VPS é mais confiável do que uma conexão e uma fonte de energia domésticas. Um meio-termo comum é o LND em casa e o Mostro num VPS, ligados por uma VPN (veja 2.2).

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 cliente Mostro — o Mostro App para Android, iOS, desktop e web, ou o mostro-cli ou o Mostrix — e da chave pública do seu Mostro (npub). No app eles vão a Configurações → Rede → Nó Mostro → Adicionar seu próprio nó e colam seu npub; os nós listados neste site já aparecem ali. O cliente se comunica através dos relays Nostr. Não é necessária conexão direta.

Meu nó ainda pode atender clientes antigos (protocolo v1)?

Não. Desde a v0.19.0 o Mostro fala apenas o protocolo v2 (4.8). Os usuários de um cliente antigo precisam atualizar para o Mostro App ou para um Mostrix ou mostro-cli atual.

Meus usuários podem operar USDT, Liquid ou Rootstock em vez de fiat?

Sim, desde a v0.20.2: USDT, USDC, DOC, BTC on-chain, LBTC e RBTC. Você os habilita um a um, e seus solvers precisam saber como conferir essas transferências. Veja 4.12.

Os usuários podem trazer a reputação do lnp2pBot ou de outro Mostro?

Sim, se você confia na fonte. Ative a importação de reputação e adicione a chave do lnp2pBot, ou a de um nó Mostro em que você confia (4.13). Você também pode deixar seus usuários exportarem a reputação que ganharam no seu nó.

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. Desde a v0.18.3 há também um prazo para o escrow: se o nó ficar fora o tempo suficiente para a hold invoice se aproximar do seu horizonte CLTV, o LND a cancela e o vendedor é reembolsado automaticamente. Se for o seu LND que sai de sincronia enquanto o Mostro continua rodando, os pagamentos esperam em vez de falhar e, após 10 minutos, o nó entra em manutenção por conta própria até o LND se recuperar (5.4).

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.

Posso mover o Mostro para outro nó Lightning?

Sim, mas não editando a configuração e reiniciando. O escrow está ligado ao nó que o criou, então primeiro se drena em modo manutenção, e o daemon se recusa a iniciar se você pular isso. Mover o mesmo nó para outro host não é troca de nó e não precisa de nada especial. Veja 5.8.

8. Considerações de Segurança

⚠️ Aviso de software em estágio inicial

Mostro está em estágio inicial de desenvolvimento. Embora a equipe trabalhe duro para garantir confiabilidade, pode haver bugs não descobertos — incluindo bugs de segurança que podem resultar em perda de fundos. Os desenvolvedores não são responsáveis por qualquer perda de dinheiro devido a bugs de software.

Mostro é open-source e seu código está aberto para auditorias. Encorajamos as comunidades a promover e financiar auditorias de segurança independentes.

Dito isso, o mecanismo central de custódia usando hold invoices Lightning tem sido testado em batalha desde 2021, quando o @lnp2pBot implementou pela primeira vez esse tipo de custódia. Milhares de operações foram concluídas com sucesso.

Mantenha a Chave do Seu Nó Fora de Alcance

Sua nsec_privkey é a identidade do seu nó, e qualquer um que a tenha pode se passar pelo seu Mostro. Prefira fornecê-la pela variável de ambiente MOSTRO_NSEC_PRIVKEY ou por um arquivo .env com chmod 600 em vez de deixá-la no settings.toml (veja 4.1). Também não a leve num laptop para atender disputas: registre uma chave de solver separada para isso (veja 5.2).

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. Seu evento de info publica a pubkey do LND e os endereços que ele anuncia, então faça o LND anunciar apenas endereços Tor.
  5. Saiba o que o seu nó publica. O evento de saúde (5.4) é público: status, altura de blocos e rede do LND, versão do Mostro. Definir um watchdog_pubkey adiciona uma tag que vincula o seu nó a essa chave. Desligue-o com [health] enabled = false se isso importar mais que o monitoramento.
  6. As variáveis de proxy não bastam. As consultas de endereços Lightning ignoram de propósito HTTP_PROXY/HTTPS_PROXY. Para ocultar o IP do servidor, encaminhe a máquina inteira pelo Tor ou por uma VPN.
💡 Dica

A beleza de o Mostro ser descentralizado é que mesmo se um nó for desligado, outros continuam funcionando. Mas a prevenção é sempre melhor que a recuperação. Leve a privacidade a sério desde o primeiro dia.

9. Solução de Problemas

Mostro não inicia

dev_fee_percentage (0.05) is below minimum (0.1)

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.

O Mostro encerra na inicialização com Ln node error

REFUSING TO START: Lightning node changed

O Mostro aponta para uma identidade LND diferente enquanto há escrow aberto na anterior. Reconecte o nó antigo e drene-o antes de trocar. Veja 5.8.

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

Apague a linha transport do settings.toml. Veja 4.8.

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

Defina a margem entre 18 e hold_invoice_cltv_delta; os 24 do template com 144 funcionam. Veja 4.9.

unknown field mint_url

Em [cashu], renomeie-a para mint_urls = ["..."]. Veja 4.11.

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

Defina bond_cltv_delta explicitamente dentro desses limites. Na v0.20.2, as cauções com um hold_invoice_cltv_delta de 288 ou mais caem nisto com o valor padrão. Veja 4.11.

REFUSING TO START: serbero_pubkey ...

A chave do Serbero já é um solver read-write, pertence a um usuário ou é a chave do seu próprio nó. Dê ao Serbero uma chave só dele. Veja 5.10.

As configurações de reputação impedem a inicialização

Os nomes dos emissores devem ser únicos e cada chave válida e listada uma só vez; a chave de um emissor nunca deve passar para outro nome depois que tem importações. Com a exportação ligada, MOSTRO_REPUTATION_ISSUER_SK deve estar definida, ser válida, diferente da chave do seu nó e não estar na sua própria lista de importação. Veja 4.13.

Os clientes não veem minhas ordens ou não conseguem escrever para o meu nó

Seu nó fala apenas o protocolo v2. Um usuário de um cliente antigo, que só fala v1, não recebe resposta e precisa atualizar (4.8). Confira também se os clientes e o seu nó compartilham pelo menos um relay.

Os pagamentos falham com "no route"

Confira payment_cltv_limit. Deve ficar pelo menos 576 blocos acima de max_final_cltv_expiry_delta e não deve exceder o --max-cltv-expiry do seu LND. Veja 4.9.

Problemas de conexão

Mostro inicia mas não conecta aos relays

Problemas com operações

Um usuário recebe "cant-do: too_many_requests" ao restaurar sessão

Isso acontece quando o usuário tem mais ordens (históricas + ativas) que o valor de max_orders_per_response na sua configuração. O cliente tenta consultar todas as ordens de uma vez e o Mostro rejeita. Não é um ban nem um bloqueio temporário — continuará acontecendo até que você ajuste o valor.

# Em settings.toml, aumente o limite:
max_orders_per_response = 50  # o padrão é 10, o máximo 255

O valor é guardado em um único byte, então 255 é o teto. Se um usuário tem mais ordens que isso, ele precisa limpar o histórico em vez de você seguir subindo o limite.

Ordens não aparecem nos clientes

Pagamentos falhando

Os pagamentos não saem, mas não há erro

Confira se o LND está sincronizado: lncli getinfo. Enquanto não estiver, o Mostro segura os pagamentos de propósito e os reenvia quando o LND se recupera (5.4).

Os usuários recebem recusas de "manutenção" embora eu nunca a tenha ativado

mostro-cli admmaintenancestatus mostra o motivo. lnd_unsynced significa que o Mostro a ativou porque o LND saiu de sincronia; ele a desfaz sozinho 5 minutos depois de o LND voltar a estar sincronizado (5.4).

As dev fees nunca são pagas

Em testnet, signet ou regtest isso é esperado: as dev fees só são pagas na mainnet (4.2).

As ordens a preço de mercado numa moeda são recusadas

Seu nó não tem taxa para ela. Confira os avisos price: no log de inicialização: um bloco [price] sem nenhuma fonte de mercado habilitada, ou uma stablecoin cotada mas não listada em fiat_currencies_accepted, são as causas habituais. Veja 4.10 e 4.12.

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

ArquivoDocker HubNativo
Configuração~/mostro-config/settings.toml/opt/mostro/settings.toml
Banco de dados~/mostro-config/mostro.db/opt/mostro/mostro.db
Cert LND~/mostro-config/lnd/tls.certVaria (verifique config LND)
Macaroon LND~/mostro-config/lnd/mostro.macaroonVaria (verifique config LND)
ServiçoN/A/etc/systemd/system/mostro.service
Logsdocker logs -f mostrojournalctl -u mostro

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*2 - COALESCE(dev_fee, 0)) FROM orders WHERE status='success';"  # Taxas líquidas mantidas pelo nó

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

Este guia é mantido pela comunidade Mostro. Encontrou um erro ou quer melhorá-lo?
Contribuições são bem-vindas em github.com/MostroP2P/community

Última atualização: Outubro de 2026 · Mostro v0.20.2