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

### सत्यापन

सत्यापित करें कि बिल्ड सफलतापूर्वक पूर्ण हुआ:```bash
ls -lh bin/
# Expected output: server and client binaries (1-5 MB each)

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

आपको ऐसा आउटपुट देखना चाहिए:```text
RedTeamCoin Mining Pool Server
Authentication Token: abc123def456...
Dashboard URL: http://localhost:8080?token=abc123def456...
gRPC server listening on port 50051

आपको माइनिंग गतिविधि देखनी चाहिए:```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...

आपको सक्रिय माइनर, हैश रेट और माइन किए गए ब्लॉकों सहित वास्तविक समय के आँकड़े दिखाई देंगे।

**नोट:** सर्वर सभी नेटवर्क इंटरफेस पर सुनता है - रिमोट एक्सेस के लिए `localhost`
को अपने सर्वर के IP से बदलें।

## यह कैसे काम करता है

माइनिंग पूल प्रूफ-ऑफ-वर्क सर्वसम्मति तंत्र का उपयोग करके संचालित होता है:

1. सर्वर जेनेसिस ब्लॉक के साथ ब्लॉकचेन को आरंभ करता है
2. माइनर gRPC के माध्यम से कनेक्ट होते हैं और IP/होस्टनाम के साथ पंजीकरण करते हैं
3. सर्वर कार्य असाइनमेंट (ब्लॉक टेम्पलेट) वितरित करता है
4. माइनर वैध नॉन्स खोजने के लिए SHA-256 हैश की गणना करते हैं
5. जब कठिनाई लक्ष्य पूरा हो जाता है तो माइनर समाधान प्रस्तुत करते हैं
6. सर्वर सत्यापित करता है और ब्लॉकों को ब्लॉकचेन में जोड़ता है
7. डैशबोर्ड वास्तविक समय के आँकड़े और माइनर गतिविधि प्रदर्शित करता है

प्रत्येक ब्लॉक के लिए अग्रणी शून्य की एक विशिष्ट संख्या के साथ एक हैश खोजने की आवश्यकता होती है
(कॉन्फ़िगर करने योग्य कठिनाई)। माइनर को प्रति ब्लॉक 50 RTC प्राप्त होता है।

### डेटा प्रवाह```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----------|

- gRPC सर्वर: पोर्ट **50051**
- वेब डैशबोर्ड: **http://localhost:8080**

**HTTPS/TLS (अनुशंसित):**```bash
# Generate certificates (one time)
./generate_certs.sh

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

**एकाधिक माइनर चलाएँ:**
अतिरिक्त टर्मिनल खोलें और प्रत्येक में `./bin/client` चलाएँ।

#### Java माइनर

RedTeamCoin दो Java माइनर कार्यान्वयन प्रदान करता है:

##### Java gRPC क्लाइंट (हेडलेस)

सर्वर और स्वचालन के लिए प्रोडक्शन-रेडी gRPC क्लाइंट।

**पूर्वापेक्षाएँ:**

- Java 11 या उसके बाद
- Maven (केवल बिल्ड के लिए)

**Makefile का उपयोग करके बिल्ड करें:**```bash
make build-java-client

**चलाएँ:**```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

**या मैन्युअली बनाएँ:**```bash
cd java-standalone
mvn clean package

**Features:**

- डेस्कटॉप GUI इंटरफ़ेस
- विज़ुअल सांख्यिकी प्रदर्शन
- सरल JSON/Socket प्रोटोकॉल
- अनुप्रयोगों में एम्बेडेड

##### सभी Java Miners बनाएँ```bash
make build-java-all

**पर्यावरण चर का उपयोग करना:**```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

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

संपूर्ण GPU माइनिंग गाइड के लिए [docs/GPU_MINING.md](https://github.com/xyplex3/redteamcoin/blob/HEAD/docs/GPU_MINING.md) देखें।

## कॉन्फ़िगरेशन

RedTeamCoin लचीले कॉन्फ़िगरेशन प्रबंधन के लिए [Viper](https://github.com/spf13/viper) का उपयोग करता है।
सेटिंग्स को पर्यावरण चर, YAML कॉन्फ़िग फ़ाइलों, या कमांड-लाइन फ़्लैग के माध्यम से निर्दिष्ट किया जा सकता है,
निम्नलिखित प्राथमिकता के साथ:

**कमांड-लाइन फ़्लैग** > **पर्यावरण चर** > **कॉन्फ़िग फ़ाइलें** > **डिफ़ॉल्ट**

### सेटअप

**कॉन्फ़िगरेशन फ़ाइलें आरंभ करें:**```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

### पर्यावरण चर

सभी पर्यावरण चर उपसर्गों का उपयोग करते हैं: `RTC_SERVER_` सर्वर के लिए, `RTC_CLIENT_` क्लाइंट के लिए।

**सर्वर कॉन्फ़िगरेशन:**

| Variable                                | Description                   | Default            |
| --------------------------------------- | ----------------------------- | ------------------ |
| `RTC_SERVER_NETWORK_GRPC_PORT`          | gRPC सर्वर पोर्ट              | `50051`            |
| `RTC_SERVER_NETWORK_API_PORT`           | HTTPS API पोर्ट               | `8443`             |
| `RTC_SERVER_NETWORK_HTTP_PORT`          | HTTP वेब इंटरफ़ेस पोर्ट       | `8080`             |
| `RTC_SERVER_MINING_DIFFICULTY`          | माइनिंग कठिनाई (1-64)         | `6`                |
| `RTC_SERVER_MINING_BLOCK_REWARD`        | सिक्कों में ब्लॉक इनाम        | `50`               |
| `RTC_SERVER_TLS_ENABLED`                | HTTPS/TLS सक्षम करें          | `false`            |
| `RTC_SERVER_TLS_CERT_FILE`              | TLS प्रमाणपत्र पथ             | `certs/server.crt` |
| `RTC_SERVER_TLS_KEY_FILE`               | TLS निजी कुंजी पथ             | `certs/server.key` |
| `RTC_SERVER_API_READ_TIMEOUT`           | API रीड टाइमआउट               | `15s`              |
| `RTC_SERVER_API_WRITE_TIMEOUT`          | API राइट टाइमआउट              | `15s`              |
| `RTC_SERVER_API_IDLE_TIMEOUT`           | API आइडल टाइमआउट              | `60s`              |
| `RTC_SERVER_LOGGING_UPDATE_INTERVAL`    | आँकड़े अद्यतन अंतराल          | `30s`              |
| `RTC_SERVER_LOGGING_FILE_PATH`          | लॉग फ़ाइल पथ                  | `pool_log.json`    |
| `RTC_AUTH_TOKEN` *(legacy)*             | कस्टम प्रमाणीकरण टोकन        | Auto-generated     |

**क्लाइंट कॉन्फ़िगरेशन:**

| Variable                                          | Description                         | Default           |
| ------------------------------------------------- | ----------------------------------- | ----------------- |
| `RTC_CLIENT_SERVER_ADDRESS`                       | पूल सर्वर पता (host:port)           | `localhost:50051` |
| `RTC_CLIENT_SERVER_TLS_ENABLED`                   | gRPC कनेक्शन के लिए TLS सक्षम करें | `false`           |
| `RTC_CLIENT_SERVER_TLS_INSECURE_SKIP_VERIFY`      | प्रमाणपत्र सत्यापन छोड़ें           | `true`            |
| `RTC_CLIENT_SERVER_TLS_CA_CERT_FILE`              | CA प्रमाणपत्र फ़ाइल का पथ           | `""`              |
| `RTC_CLIENT_MINING_GPU_ENABLED`                   | GPU माइनिंग सक्षम करें              | `true`            |
| `RTC_CLIENT_MINING_HYBRID_MODE`                   | CPU+GPU एक साथ माइनिंग सक्षम करें  | `false`           |
| `RTC_CLIENT_MINING_AUTO_DELETE`                   | शटडाउन पर स्वतः-हटाएँ               | `true`            |
| `RTC_CLIENT_GPU_NONCE_RANGE`                      | प्रति GPU बैच नॉन्स रेंज             | `500000000`       |
| `RTC_CLIENT_GPU_CPU_START_NONCE`                  | CPU प्रारंभ नॉन्स (GPU ओवरलैप से बचें) | `5000000000`      |
| `RTC_CLIENT_NETWORK_HEARTBEAT_INTERVAL`           | स्थिति अद्यतन अंतराल                | `30s`             |
| `RTC_CLIENT_NETWORK_RETRY_INTERVAL`               | कनेक्शन पुनःप्रयास विलंब            | `10s`             |
| `RTC_CLIENT_NETWORK_MAX_RETRY_TIME`               | अधिकतम पुनःप्रयास अवधि              | `5m`              |
| `RTC_CLIENT_BEHAVIOR_WORKER_UPDATE_INTERVAL`      | वर्कर प्रगति रिपोर्ट अंतराल         | `100000`          |
| `POOL_SERVER` *(legacy)*                          | रिमोट सर्वर पता                     | `localhost:50051` |
| `GPU_MINING` *(legacy)*                           | GPU माइनिंग सक्षम/अक्षम करें        | Auto-detect       |
| `HYBRID_MINING` *(legacy)*                        | CPU+GPU माइनिंग सक्षम करें          | `false`           |

### कॉन्फ़िग फ़ाइल उदाहरण

**सर्वर कॉन्फ़िग** (`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

### प्रमाणीकरण

सभी API एंडपॉइंट (डैशबोर्ड होमपेज को छोड़कर) के लिए Bearer टोकन प्रमाणीकरण आवश्यक है।

**स्वतः-जनरेटेड टोकन:**
सर्वर स्टार्टअप पर एक सुरक्षित टोकन जनरेट करता है और उसे कंसोल में प्रदर्शित करता है।

**कस्टम टोकन:**```bash
export RTC_AUTH_TOKEN="your-secret-token"
./bin/server

TLS विस्तृत कॉन्फ़िगरेशन के लिए [docs/TLS_SETUP.md](https://github.com/xyplex3/redteamcoin/blob/HEAD/docs/TLS_SETUP.md) देखें।

## API संदर्भ

### REST API एंडपॉइंट्स

**सार्वजनिक एंडपॉइंट्स:**

- `GET /` - वेब डैशबोर्ड (HTML)
- `GET /blocks` - सभी ब्लॉक पेज देखें (HTML)

**प्रमाणित एंडपॉइंट्स:**

- `GET /api/stats` - पूल आँकड़े (JSON)
- `GET /api/miners` - सभी माइनर्स की सूची (JSON)
- `GET /api/blockchain` - संपूर्ण ब्लॉकचेन (JSON)
- `GET /api/blocks/{index}` - विशिष्ट ब्लॉक विवरण (JSON)
- `GET /api/validate` - ब्लॉकचेन अखंडता सत्यापित करें (JSON)
- `GET /api/cpu` - CPU और GPU उपयोग आँकड़े (JSON)
- `POST /api/miner/pause` - किसी विशिष्ट माइनर के लिए माइनिंग रोकें
- `POST /api/miner/resume` - किसी विशिष्ट माइनर के लिए माइनिंग फिर से शुरू करें
- `POST /api/miner/delete` - माइनर हटाएं (स्वतः समाप्त और स्व-हटाने वाला)
- `POST /api/miner/throttle` - CPU थ्रॉटल प्रतिशत सेट करें (0-100%)

### प्रमाणीकरण उदाहरण

**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())

## आर्किटेक्चर

### टेक्नोलॉजी स्टैक

- **भाषा**: Go 1.21+
- **RPC फ्रेमवर्क**: gRPC के साथ Protocol Buffers
- **वेब सर्वर**: Go net/http मानक पुस्तकालय
- **निर्भरताएँ**: google.golang.org/protobuf, google.golang.org/grpc

## विकास

### बिल्ड कमांड```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

**विशिष्ट परीक्षण सूट चलाएँ:**```bash
# Server tests
cd server && go test -v

# Client tests
cd client && go test -v -short

# With coverage
cd server && go test -cover
cd client && go test -cover

बनाता है `bin/client.exe`

**OpenCL के साथ Windows (GPU समर्थन):**```bash
# Requires MinGW-w64 and Windows OpenCL SDK
make build-windows-opencl

बनाता है:

- `client-linux-amd64` - लिनक्स 64-बिट
- `client-linux-arm64` - लिनक्स ARM64
- `client-windows-amd64.exe` - विंडोज़ 64-बिट
- `client-darwin-amd64` - macOS इंटेल
- `client-darwin-arm64` - macOS एप्पल सिलिकॉन

**नोट:** क्रॉस-कंपाइल किए गए बाइनरी केवल CPU के लिए हैं (CGO अक्षम) जब तक कि `build-windows-opencl` का उपयोग न किया जाए।

### विश्लेषण उपकरण

खनन प्रभाव विश्लेषण के लिए क्षति आकलन रिपोर्ट उत्पन्न करें:```bash
make build-tools
./bin/generate_report -log pool_log.json

**उपयोग के मामले:**

- घटना-पश्चात विश्लेषण
- कार्यकारी ब्रीफिंग
- वित्तीय औचित्य
- अनुपालन दस्तावेज़ीकरण
- बीमा दावे
- कानूनी साक्ष्य

संपूर्ण दस्तावेज़ीकरण के लिए [tools/README.md](https://github.com/xyplex3/redteamcoin/blob/HEAD/tools/README.md) देखें।

## समस्या निवारण

### रिमोट कनेक्शन समस्याएँ

**कनेक्टिविटी का परीक्षण:**```bash
# Test connection
ping <server_ip>
nc -zv <server_ip> 50051

# Check server (on server side)
lsof -i :50051
ss -an | grep 50051

### कोड दिशानिर्देश

- Go मानक स्वरूपण (`gofmt`) का पालन करें
- नई कार्यक्षमता के लिए यूनिट परीक्षण जोड़ें
- उपयोगकर्ता-सामने वाले परिवर्तनों के लिए दस्तावेज़ अपडेट करें
- PR जमा करने से पहले सुनिश्चित करें कि सभी CI जाँचें पास हों

## सुरक्षा टिप्पणी

यह एक **प्रदर्शन/शैक्षिक परियोजना** है, जो अधिकृत सुरक्षा परीक्षण
और रेड टीम संचालन के लिए है। इसका उद्देश्य है:

- अधिकृत पेनेट्रेशन परीक्षण कार्य
- सुरक्षा नियंत्रण सत्यापन
- पहचान क्षमता मूल्यांकन
- शैक्षिक और प्रशिक्षण उद्देश्य

यह उपकरण वास्तविक क्रिप्टोकरेंसी के रूप में उत्पादन उपयोग के लिए नहीं है और
इसमें उत्पादन प्रणाली के लिए आवश्यक कई सुविधाएँ नहीं हैं (क्रिप्टोग्राफिक हस्ताक्षर,
वॉलेट, लेनदेन सत्यापन, नेटवर्क सहमति, आदि)।

**केवल उन प्रणालियों पर स्पष्ट प्राधिकरण के साथ उपयोग करें जिनके स्वामी हैं या जिनके पास परीक्षण की
अनुमति है।**

## लाइसेंस

यह परियोजना GNU जनरल पब्लिक लाइसेंस v3.0 के अंतर्गत लाइसेंस प्राप्त है - विवरण के लिए
[LICENSE](https://github.com/xyplex3/redteamcoin/blob/HEAD/LICENSE) फ़ाइल देखें।

## स्वीकृतियाँ

**निर्माता:**

- Peter Greko ([@Xyplex02](https://github.com/Xyplex02))
- Luciano Krigun ([@klucho](https://github.com/klucho))
- Jayson Grace ([@l50](https://github.com/l50))