Executando Seu Próprio Nó Mostro

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

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

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

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

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

Como Mostro Funciona (Simplificado)

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

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

2.1 Um Servidor (VPS)

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

Especificações mínimas:

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

Provedores de VPS populares:

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

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

2.2 Um Nó Lightning Network (LND)

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

Suas opções:

O que você precisa do seu nó LND:

• O arquivo tls.cert (um certificado de segurança)
• Um arquivo mostro.macaroon dedicado (um token de autenticação apenas com as permissões que o Mostro precisa, veja abaixo)
• O endereço gRPC (tipicamente https://127.0.0.1:10009 se na mesma máquina)

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

2.3 Liquidez Lightning

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

Quanto você precisa?

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

Obtendo liquidez:

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

2.4 Chaves Nostr

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

Gerando chaves Nostr seguras localmente com rana:

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

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

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

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

2.5 Nível de conhecimento técnico

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

3. Instalação Passo a Passo

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

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

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

Passos Comuns (para as 3 opções)

Passo 1: Conecte-se ao seu VPS

ssh root@SEU_ENDERECO_IP_DO_VPS

Passo 2: Atualize o sistema

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

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

Passo 3: Instalar Docker e Docker Compose

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

# Verificar se Docker está instalado
docker --version

# Verificar Docker Compose
docker compose version

Passo 4: Instalar ferramentas adicionais

apt install -y git make

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

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

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

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

mkdir -p ~/mostro-config/lnd

Passo 6: Obter o template de configuração

curl -sL https://raw.githubusercontent.com/MostroP2P/mostro/v0.19.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:

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

Passo 8: Editar a configuração

nano ~/mostro-config/settings.toml

Alterações necessárias:

[lightning]
lnd_cert_file = '/config/lnd/tls.cert'
lnd_macaroon_file = '/config/lnd/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

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:

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

Se o LND está em um servidor diferente:

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

Passo 11: Verificar os logs

docker logs -f mostro

Procure estas mensagens:

• Settings correctly loaded! — A configuração é válida
• Transport: nip44 (protocol v2, event kind 14) — Protocolo em uso (veja 4.8)
• Connected to 'wss://...' — Relay Nostr estabelecido
• Recorded Lightning node identity <pubkey> — LND alcançado (apenas na primeira execução)

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

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.

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

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

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

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

Passo 7: Baixar e compilar Mostro

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

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

Passos 8–10: Instalar, inicializar e limpar

install target/release/mostrod /usr/local/bin
cargo clean  # Economiza 2+ GB de espaço

Passos 11–12: Criar usuário e configurar

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

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

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

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

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

Criar o serviço systemd:

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

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

[Install]
WantedBy=multi-user.target

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

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

4. Configuração em Detalhe

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

4.1 Chaves Nostr — A identidade do seu nó

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

Quais relays usar?

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

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.

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

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

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

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

4.3 Limites de ordens e moedas

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

• max_order_amount: Maior operação em satoshis. Configure baseado na capacidade dos seus canais Lightning.
• min_payment_amount: Operação mínima em satoshis. 1.000 ou 10.000 é mais prático que 100.
• max_orders_per_response: Quantidade máxima de ordens que o Mostro retorna em uma única consulta. Se um usuário acumula mais ordens que esse limite (por exemplo ao restaurar sua sessão no cliente móvel), receberá um erro cant-do: too_many_requests e não conseguirá recuperar suas ordens. Se seus usuários operam com frequência, aumente esse valor (por exemplo 50 ou 100). O valor padrão de 10 pode ser insuficiente.
• fiat_currencies_accepted: Use códigos ISO 4217. Array vazio [] aceita todas as moedas.

4.4 Perfil do nó (Opcional mas recomendado)

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

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

4.5 Tempos e expiração

[mostro]
expiration_hours = 24        # Quanto tempo uma ordem fica aberta
expiration_seconds = 900     # Tempo para completar (15 min)
hold_invoice_expiration_window = 300  # Tempo que o tomador tem para pagar a fatura ou fornecer uma de recebimento (5 min)

4.6 Anti-Spam

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

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.

4.8 Protocolo de Transporte

Um nó Mostro fala um único protocolo, escolhido aqui:

[mostro]
transport = "nip44"

Seu nó anuncia qual protocolo fala no seu evento de info kind 38385, então clientes compatíveis escolhem o formato por conta própria. Mostro Mobile, Mostrix e mostro-cli suportam v2.

O transporte v2 também permite um filtro anti-spam mais fino que o de 4.6. 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

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

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.

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

4.11 Outros Blocos Opcionais

Mais três blocos que você pode encontrar num template recente. Nenhum é obrigatório.

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]) podem exigir uma caução por hold invoice dos tomadores, dos criadores ou de ambos, para que abandonar uma operação tenha custo. Desabilitado por padrão e ainda em liberação por fases. Leia o docs/ANTI_ABUSE_BOND.md do projeto antes de habilitá-lo num nó em produção.

Escrow com Cashu ([cashu]) é um modo experimental que roda sem LND e mantém o escrow em tokens Cashu de uma única mint. Ainda não serve para operar de verdade, as ações de trade continuam sendo rejeitadas, e não pode ser combinado com as cauções anti-abuso. Mencionado aqui para você saber o que é esse bloco quando o vir.

5. Operando Seu Nó Mostro

5.1 Como funcionam as disputas

Disputas são sua responsabilidade operacional mais importante.

Quando ocorrem disputas?

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

O processo de disputa:

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

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.

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.

5.2 Mostrix — Sua ferramenta de administração

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

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

Baixe a última versão para sua plataforma em GitHub Releases:

# Linux (x86_64)
wget https://github.com/MostroP2P/mostrix/releases/latest/download/mostrix-x86_64-unknown-linux-musl

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

# Windows
# Baixe mostrix-x86_64-pc-windows-gnu.exe da página de releases

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

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

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

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

# Depois compare o hash do binário com o manifest
shasum -a 256 mostrix-x86_64-unknown-linux-musl
grep mostrix-x86_64-unknown-linux-musl manifest.txt

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)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

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

# Executar
./target/release/mostrix

Primeira execução e configuração

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

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

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

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

# ~/.mostrix/settings.toml
mostro_pubkey = "SUA_PUBKEY_MOSTRO_HEX"
nsec_privkey = "nsec1sua_chave_pessoal"      # Auto-gerada na primeira execução
admin_privkey = "nsec1sua_chave_admin"        # O nsec do próprio daemon — veja abaixo
relays = ["wss://relay.mostro.network"]
currencies_filter = []                        # Vazio = mostrar todas as moedas
user_mode = "admin"                           # Habilitar modo admin

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

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

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

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

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

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

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

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

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

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

Configuração:

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

[mostro]
pubkey = "SUA_PUBKEY_MOSTRO"

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

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

5.4 Monitoramento de uptime

Seu nó precisa estar funcionando 24/7.

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

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

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

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. Ler isso 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
nostreq --kinds 38385 --limit 1 --authors SUA_MOSTRO_PUBKEY_HEX \
  | nostcat --stream wss://relay.mostro.network | jq

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, então uma opção nova só tem efeito quando você a adiciona: compare seu arquivo com o novo settings.tpl.toml.
2. Faça backup do banco de dados com os comandos de 5.6. Você precisa desse backup para voltar atrás.

Docker Hub (docker run)

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

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

Nativo

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

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.

5.6 Backups

Arquivos críticos para backup: settings.toml, o arquivo .env se você guarda seu nsec ali (veja 4.1), e mostro.db (histórico de ordens, reputação).

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

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

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)

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

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

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

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.

5.9 Comandos de Operador com mostro-cli

O Mostrix é o jeito confortável de trabalhar disputas, mas o mostro-cli cobre o mesmo terreno de um shell e tem alguns comandos 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.

# Trabalho de disputas (via Nostr, precisa de ADMIN_NSEC)
export ADMIN_NSEC=nsec1...
mostro-cli listdisputes
mostro-cli admtakedispute -d <dispute-id>
mostro-cli admsenddm -p <npub> -m "mensagem para uma parte"
mostro-cli admsettle -o <order-id>      # liberar para o comprador
mostro-cli admcancel -o <order-id>      # reembolsar o vendedor

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

Outro grupo de comandos vai pelo gRPC de administração em vez do Nostr, então precisam de MOSTRO_RPC_URL e MOSTRO_RPC_TOKEN em vez de ADMIN_NSEC, e da interface RPC habilitada (veja 4.7).

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 a caução de um tomador, 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.

6. Análise de Custos

Custos operacionais mensais

Custos únicos / de capital

Potencial de receita

Compromisso de tempo

7. Perguntas Frequentes

Preciso ser desenvolvedor para executar um nó Mostro?

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

Posso executar Mostro em um Raspberry Pi?

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

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

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

Como os usuários se conectam ao meu Mostro?

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

Posso executar múltiplas instâncias de Mostro?

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

É legal?

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

Quanta largura de banda o Mostro usa?

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

O que acontece se meu nó ficar offline?

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

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

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.

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

• Verifique se o LND está executando: lncli getinfo
• Confira se lnd_grpc_host corresponde ao endereço do seu LND
• Verifique se os caminhos de tls.cert e mostro.macaroon estão corretos
• Verifique se o macaroon tem as permissões de 2.2
• Docker + LND no host: use host.docker.internal. A Opção B precisa também do mapeamento extra_hosts.

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.

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

Confira a linha Transport: nos seus logs. Um nó em nip44 é invisível para clientes que só falam o protocolo v1, e um nó em gift-wrap é invisível para clientes v2. Veja 4.8.

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

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

Problemas com operações

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

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

Pagamentos falhando

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

Problemas de banco de dados

Erros de banco de dados bloqueado

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

Obtendo ajuda

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

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

Apêndice: Referência Rápida

Localizações importantes de arquivos

Comandos essenciais

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

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

# Banco de dados
sqlite3 mostro.db "SELECT COUNT(*) FROM orders;"                           # Total de ordens
sqlite3 mostro.db "SELECT COUNT(*) FROM orders WHERE status='success';"    # Operações bem-sucedidas
sqlite3 mostro.db "SELECT SUM(fee*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'
]