**macOS:**```bash
brew install go protobuf

### Verificação

Verifique se a compilação foi concluída com sucesso:```bash
ls -lh bin/
# Expected output: server and client binaries (1-5 MB each)

./bin/server --help
# Expected output: Usage information for the server

Você deve ver uma saída como:```text
RedTeamCoin Mining Pool Server
Authentication Token: abc123def456...
Dashboard URL: http://localhost:8080?token=abc123def456...
gRPC server listening on port 50051

Você deve ver atividade de mineração:```text
Connected to mining pool at localhost:50051
Registered as miner: miner-hostname-1234567890
Mining block #1... Hash rate: 2.5 MH/s
Block found! Nonce: 98765, Hash: 000000ab1cd...

Você verá estatísticas em tempo real, incluindo mineradores ativos, taxas de hash e blocos minerados.

**Nota:** O servidor escuta em todas as interfaces de rede - substitua `localhost` pelo IP do seu servidor para acesso remoto.

## Como Funciona

O pool de mineração opera usando um mecanismo de consenso de prova de trabalho:

1. O servidor inicializa a blockchain com o bloco gênese
2. Os mineradores se conectam via gRPC e registram com IP/hostname
3. O servidor distribui atribuições de trabalho (modelos de bloco)
4. Os mineradores calculam hashes SHA-256 para encontrar nonces válidos
5. Os mineradores enviam soluções quando a meta de dificuldade é atingida
6. O servidor valida e adiciona blocos à blockchain
7. O painel exibe estatísticas em tempo real e atividade dos mineradores

Cada bloco requer encontrar um hash com um número específico de zeros à esquerda (dificuldade configurável). Os mineradores recebem 50 RTC por bloco minerado.

### Fluxo de Dados```text
Client Miner                    Server
    |                              |
    |--RegisterMiner(IP,Hostname)->|
    |<--RegistrationResponse-------|
    |--GetWork()------------------>|
    |<--WorkResponse(Block)--------|
    | [Mining: compute hashes]     |
    |--SubmitWork(nonce,hash)----->|
    |                              | [Validate proof-of-work
    |                              |  and add block to chain]
    |<--SubmissionResponse---------|
    |--Heartbeat(stats)----------->|
    |<--HeartbeatResponse----------|

- Servidor gRPC: porta **50051**
- Painel web: **http://localhost:8080**

**HTTPS/TLS (Recomendado):**```bash
# Generate certificates (one time)
./generate_certs.sh

# Start with TLS
RTC_SERVER_TLS_ENABLED=true ./bin/server

**Executar múltiplos mineradores:**
Abra terminais adicionais e execute `./bin/client` em cada um.

#### Mineradores Java

O RedTeamCoin fornece duas implementações de mineradores Java:

##### Cliente gRPC Java (Headless)

Cliente gRPC pronto para produção para servidores e automação.

**Pré-requisitos:**

- Java 11 ou posterior
- Maven (apenas para compilação)

**Compilar usando Makefile:**```bash
make build-java-client

**Executar:**```bash
# Connect to localhost
java -jar bin/redteamcoin-miner-client.jar

# Connect to remote server
java -jar bin/redteamcoin-miner-client.jar -server 192.168.1.100:50051

**Ou construir manualmente:**```bash
cd java-standalone
mvn clean package

**Funcionalidades:**

- Interface gráfica de ambiente de trabalho  
- Exibição de estatísticas visuais  
- Protocolo JSON/Socket simples  
- Incorporado em aplicações  

##### Compilar Todos os Miners Java```bash
make build-java-all

**Usando variável de ambiente:**```bash
export RTC_CLIENT_SERVER_ADDRESS=192.168.1.100:50051
./bin/client

**AMD/Intel OpenCL:**```bash
sudo apt install ocl-icd-opencl-dev
make build-opencl

### Uso da GPU```bash
# Auto-detect GPU (default)
./bin/client

# Force CPU only
RTC_CLIENT_MINING_GPU_ENABLED=false ./bin/client

# Hybrid mode (CPU + GPU)
RTC_CLIENT_MINING_HYBRID_MODE=true ./bin/client

# GPU with remote server
./bin/client -server mining-pool.example.com:50051

Veja [docs/GPU_MINING.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/GPU_MINING.md) para o guia completo de mineração GPU.

## Configuração

RedTeamCoin usa [Viper](https://github.com/spf13/viper) para gerenciamento flexível de configuração. As configurações podem ser especificadas por meio de variáveis de ambiente, arquivos de configuração YAML ou flags de linha de comando com a seguinte precedência:

**Flags de linha de comando** > **Variáveis de ambiente** > **Arquivos de configuração** > **Padrões**

### Configuração

**Inicialize os arquivos de configuração:**```bash
# Initialize both server and client configs
make init-config

# Or initialize individually
make init-server-config  # Creates server-config.yaml
make init-client-config  # Creates client-config.yaml

### Variáveis de Ambiente

Todas as variáveis de ambiente usam prefixos: `RTC_SERVER_` para servidor, `RTC_CLIENT_` para cliente.

**Configuração do Servidor:**

| Variável                                | Descrição                   | Padrão            |
| --------------------------------------- | ----------------------------- | ------------------ |
| `RTC_SERVER_NETWORK_GRPC_PORT`          | Porta do servidor gRPC              | `50051`            |
| `RTC_SERVER_NETWORK_API_PORT`           | Porta da API HTTPS                | `8443`             |
| `RTC_SERVER_NETWORK_HTTP_PORT`          | Porta da interface web HTTP       | `8080`             |
| `RTC_SERVER_MINING_DIFFICULTY`          | Dificuldade de mineração (1-64)      | `6`                |
| `RTC_SERVER_MINING_BLOCK_REWARD`        | Recompensa do bloco em moedas         | `50`               |
| `RTC_SERVER_TLS_ENABLED`                | Habilitar HTTPS/TLS              | `false`            |
| `RTC_SERVER_TLS_CERT_FILE`              | Caminho do certificado TLS          | `certs/server.crt` |
| `RTC_SERVER_TLS_KEY_FILE`               | Caminho da chave privada TLS               | `certs/server.key` |
| `RTC_SERVER_API_READ_TIMEOUT`           | Timeout de leitura da API              | `15s`              |
| `RTC_SERVER_API_WRITE_TIMEOUT`          | Timeout de escrita da API             | `15s`              |
| `RTC_SERVER_API_IDLE_TIMEOUT`           | Timeout de ociosidade da API              | `60s`              |
| `RTC_SERVER_LOGGING_UPDATE_INTERVAL`    | Intervalo de atualização de estatísticas         | `30s`              |
| `RTC_SERVER_LOGGING_FILE_PATH`          | Caminho do arquivo de log                 | `pool_log.json`    |
| `RTC_AUTH_TOKEN` *(legado)*             | Token de autenticação personalizado   | Auto-gerado     |

**Configuração do Cliente:**

| Variável                                          | Descrição                         | Padrão           |
| ------------------------------------------------- | ----------------------------------- | ----------------- |
| `RTC_CLIENT_SERVER_ADDRESS`                       | Endereço do servidor do pool (host:porta)     | `localhost:50051` |
| `RTC_CLIENT_SERVER_TLS_ENABLED`                   | Habilitar TLS para conexão gRPC      | `false`           |
| `RTC_CLIENT_SERVER_TLS_INSECURE_SKIP_VERIFY`      | Pular verificação de certificado       | `true`            |
| `RTC_CLIENT_SERVER_TLS_CA_CERT_FILE`              | Caminho para o arquivo de certificado CA         | `""`              |
| `RTC_CLIENT_MINING_GPU_ENABLED`                   | Habilitar mineração GPU                   | `true`            |
| `RTC_CLIENT_MINING_HYBRID_MODE`                   | Habilitar mineração simultânea CPU+GPU  | `false`           |
| `RTC_CLIENT_MINING_AUTO_DELETE`                   | Exclusão automática ao desligar             | `true`            |
| `RTC_CLIENT_GPU_NONCE_RANGE`                      | Intervalo de nonce por lote de GPU           | `500000000`       |
| `RTC_CLIENT_GPU_CPU_START_NONCE`                  | Nonce inicial da CPU (evitar sobreposição com GPU) | `5000000000`      |
| `RTC_CLIENT_NETWORK_HEARTBEAT_INTERVAL`           | Intervalo de atualização de status              | `30s`             |
| `RTC_CLIENT_NETWORK_RETRY_INTERVAL`               | Atraso de retentativa de conexão              | `10s`             |
| `RTC_CLIENT_NETWORK_MAX_RETRY_TIME`               | Duração máxima de retentativa                  | `5m`              |
| `RTC_CLIENT_BEHAVIOR_WORKER_UPDATE_INTERVAL`      | Intervalo de relatório de progresso do worker     | `100000`          |
| `POOL_SERVER` *(legado)*                          | Endereço do servidor remoto               | `localhost:50051` |
| `GPU_MINING` *(legado)*                           | Habilitar/desabilitar mineração GPU           | Auto-detectar       |
| `HYBRID_MINING` *(legado)*                        | Habilitar mineração CPU+GPU               | `false`           |

### Exemplos de Arquivos de Configuração

**Configuração do servidor** (`server-config.yaml`):```yaml
network:
  grpc_port: 50051
  api_port: 8443
  http_port: 8080
mining:
  difficulty: 8
  block_reward: 100
tls:
  enabled: true
  cert_file: /etc/rtc/certs/server.crt
  key_file: /etc/rtc/certs/server.key
logging:
  update_interval: 30s
  file_path: /var/log/rtc/pool.json

### Autenticação

Todos os endpoints da API (exceto a página inicial do dashboard) exigem autenticação via token Bearer.

**Token gerado automaticamente:**
O servidor gera um token seguro na inicialização e o exibe no console.

**Token personalizado:**```bash
export RTC_AUTH_TOKEN="your-secret-token"
./bin/server

See [docs/TLS_SETUP.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/TLS_SETUP.md) para configuração detalhada de TLS.

## Referência da API

### Endpoints da API REST

**Endpoints públicos:**

- `GET /` - Painel web (HTML)
- `GET /blocks` - Ver página de todos os blocos (HTML)

**Endpoints autenticados:**

- `GET /api/stats` - Estatísticas da pool (JSON)
- `GET /api/miners` - Lista de todos os mineradores (JSON)
- `GET /api/blockchain` - Blockchain completo (JSON)
- `GET /api/blocks/{index}` - Detalhes do bloco específico (JSON)
- `GET /api/validate` - Validar integridade da blockchain (JSON)
- `GET /api/cpu` - Estatísticas de uso de CPU e GPU (JSON)
- `POST /api/miner/pause` - Pausar mineração para um minerador específico
- `POST /api/miner/resume` - Retomar mineração para um minerador específico
- `POST /api/miner/delete` - Excluir um minerador (auto-termina e auto-exclui)
- `POST /api/miner/throttle` - Definir porcentagem de limitação de CPU (0-100%)

### Exemplos de Autenticação

**cURL:**```bash
# Get stats
curl -H "Authorization: Bearer YOUR_TOKEN" http://localhost:8080/api/stats

# Get miners
curl -H "Authorization: Bearer YOUR_TOKEN" http://localhost:8080/api/miners

# Pause a miner
curl -X POST -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"miner_id":"miner-hostname-1234567890"}' \
  http://localhost:8080/api/miner/pause

# Set CPU throttle to 50%
curl -X POST -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"miner_id":"miner-hostname-1234567890","throttle_percent":50}' \
  http://localhost:8080/api/miner/throttle

# HTTPS (with self-signed cert)
curl -k -H "Authorization: Bearer YOUR_TOKEN" https://localhost:8443/api/stats

**Python:**```python
import requests

headers = {'Authorization': 'Bearer YOUR_TOKEN'}
response = requests.get('http://localhost:8080/api/stats', headers=headers)
print(response.json())

## Arquitetura

### Stack de Tecnologia

- **Linguagem**: Go 1.21+
- **Framework RPC**: gRPC com Protocol Buffers
- **Servidor Web**: Biblioteca padrão Go net/http
- **Dependências**: google.golang.org/protobuf, google.golang.org/grpc

## Desenvolvimento

### Comandos de Build```bash
make proto                # Generate protobuf code
make build                # Build server and client (CPU only)
make build-gpu            # Build with GPU support (auto-detect)
make build-cuda           # Build with NVIDIA CUDA
make build-opencl         # Build with AMD/Intel OpenCL
make build-windows        # Cross-compile for Windows
make build-all-platforms  # Cross-compile for all platforms
make clean                # Remove build artifacts
make deps                 # Download dependencies
make init                 # Full initialization

python -m pytest
``````bash
make test                 # Run all tests (server + client)

**Cobertura de Testes:**

- **Servidor**: 76 testes, 66,3% de cobertura

  - `blockchain_test.go`: 15 testes - Validação de blockchain, cálculo de hash,
    acesso concorrente
  - `pool_test.go`: 26 testes - Gerenciamento de mineradores, distribuição de trabalho, estatísticas
  - `grpc_server_test.go`: 17 testes - Endpoints gRPC, controle de mineradores, heartbeats
  - `api_test.go`: 18 testes - API REST, autenticação, operações de mineradores

- **Cliente**: 41 testes, 16,2% de cobertura
  - `main_test.go`: 24 testes - Lógica de mineração, cálculo de hash, gerenciamento de estado
  - `gpu_test.go`: 18 testes - Detecção de GPU, gerenciamento de dispositivos, estatísticas

**Total**: 117 testes unitários cobrindo funcionalidades principais

**O que é testado:**

- Validação e integridade do blockchain
- Mineração de blocos e prova de trabalho
- Distribuição de trabalho em pool de mineração
- Registro e gerenciamento de mineradores
- Controle de mineradores no servidor (pausar/retomar/excluir/limitar)
- Protocolos de comunicação gRPC
- Endpoints da API REST e autenticação
- Detecção e inicialização de dispositivos GPU
- Cálculo de taxa de hash e estatísticas
- Operações concorrentes e segurança de threads
- Tratamento de erros e casos extremos

**Testes CI/CD:**

Todos os testes são executados automaticamente em:

- Pull requests
- Commits no branch principal
- Builds de release

Veja [.github/workflows/build-verification.yaml](https://github.com/xyplex3/redteamcoin/blob/main/.github/workflows/build-verification.yaml) para configuração de CI.

### Compilação Cruzada

**Windows (somente CPU):**```bash
make build-windows

Cria `bin/client-windows-opencl.exe`

Consulte [docs/WINDOWS_BUILD.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/WINDOWS_BUILD.md) para obter instruções completas de compilação no Windows, incluindo:

- Compilações nativas do Windows com suporte a GPU
- Configuração de compilação cruzada a partir do Linux
- Configuração do token de autenticação
- Guia de solução de problemas

**Múltiplas plataformas:**```bash
make build-all-platforms

**O relatório inclui:**

- Análise de consumo de recursos
- Avaliação de impacto no desempenho
- Danos à infraestrutura
- Implicações de segurança
- Resumo do impacto financeiro
- Análise sistema por sistema
- Recomendações de remediação

**Premissas de Custo:**

| Parâmetro          | Padrão    | Notas                 |
| ------------------ | --------- | --------------------- |
| Potência da CPU    | 150W      | Carga total           |
| Potência da GPU    | 250W      | Carga total           |
| Eletricidade       | $0,12/kWh | Ajuste conforme a região |
| Redução da Vida Útil | 20-40%    | Devido à mineração contínua |

**Convertendo Relatórios:**```bash
# PDF
pandoc Report_Miner_Activity_from_<date>_to_<date>.md -o report.pdf

# HTML
pandoc Report_Miner_Activity_from_<date>_to_<date>.md -o report.html

# DOCX
pandoc Report_Miner_Activity_from_<date>_to_<date>.md -o report.docx

**Problemas comuns:**

- Verifique o endereço e a porta do servidor
- Certifique-se de que o servidor está em execução
- Verifique as regras de firewall (cliente e servidor)
- Confirme a conectividade de rede
- Verifique se a porta 50051 está escutando

### Problemas com Mineração GPU

| Problema              | Solução                                                        |
| -------------------- | --------------------------------------------------------------- |
| "não é possível encontrar -lcuda" | `export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH` |
| "nvcc não encontrado"     | `sudo apt install cuda-toolkit`                                 |
| "Nenhum dispositivo OpenCL"   | `sudo apt install ocl-icd-opencl-dev`                           |
| GPU lenta             | `export RTC_CLIENT_MINING_GPU_ENABLED=true`                     |
| Erro de compilação CGo      | `sudo apt install build-essential`                              |

### Problemas Gerais

**Falhas de compilação:**

- Certifique-se de que o Go 1.21+ está instalado
- Execute `make deps` para instalar as dependências
- Execute `make install-tools` para as ferramentas protoc

**Conexão recusada:**

- Verifique se o servidor está em execução
- Verifique se a porta não está em uso: `lsof -i :50051`
- Verifique as configurações de firewall

**Erros de autenticação:**

- Verifique se o token corresponde à saída do servidor
- Verifique o formato do cabeçalho `Authorization: Bearer TOKEN`
- Certifique-se de que o token está incluído na URL ou nos cabeçalhos

## Documentação

### Guias do Usuário

- [docs/GPU_MINING.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/GPU_MINING.md) - Mineração GPU com CUDA e OpenCL
- [docs/WINDOWS_BUILD.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/WINDOWS_BUILD.md) - Guia de compilação para Windows (nativa e compilação cruzada)
- [docs/TLS_SETUP.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/TLS_SETUP.md) - Configuração HTTPS/TLS
- [java-client/README.md](https://github.com/xyplex3/redteamcoin/blob/main/java-client/README.md) - Cliente gRPC Java (minerador headless)
- [tools/README.md](https://github.com/xyplex3/redteamcoin/blob/main/tools/README.md) - Ferramentas de análise e relatórios de danos

### Referências Técnicas

- [docs/WORKFLOWS.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/WORKFLOWS.md) - Fluxos de trabalho CI/CD e processos de desenvolvimento

### Exemplos

- [docs/examples/](https://github.com/xyplex3/redteamcoin/blob/main/docs/examples) - Relatórios de exemplo e exemplos de uso

## Contribuindo

Aceitamos contribuições! Veja como começar:

1. Faça um fork do repositório
2. Crie um branch de funcionalidade: `git checkout -b feature/amazing-feature`
3. Faça suas alterações e adicione testes
4. Execute a suíte de testes: `make test`
5. Faça commit das suas alterações: `git commit -m 'Add amazing feature'`
6. Envie para o branch: `git push origin feature/amazing-feature`
7. Abra um Pull Request

### Configuração de Desenvolvimento```bash
# Clone your fork
git clone https://github.com/YOUR_USERNAME/RedTeamCoin.git
cd RedTeamCoin

# Install dependencies
make install-tools
make deps

# Run tests
make test

# Build and test locally
make build
make run-server  # Terminal 1
make run-client  # Terminal 2