### Start Mining (Random Extranonce2 + Full Nonce Scan)

Source: https://github.com/dhmyess/pycudabtcminer/blob/main/README.md

Launches the Bitcoin miner using a random extranonce2 value and performing a full scan of nonces from 0 to 4,294,967,295. This method is recommended for GPUs with a hashrate exceeding 4,294 MH/s.

```bash
python3 miner.py
```

--------------------------------

### Mining Configuration Example

Source: https://github.com/dhmyess/pycudabtcminer/blob/main/README.md

Configuration dictionary for PyCudaBTCMiner, specifying connection details for a mining pool and user credentials. This configuration is used by both `miner.py` and `random_miner.py`. Ensure you replace 'YOUR_BITCOIN_ADDRESS' with your actual Bitcoin wallet address.

```python
config = {
    "pool_address": "public-pool.io",  # Mining pool address
    "pool_port": 3333,                 # Mining pool port
    "user_name": "YOUR_BITCOIN_ADDRESS", # Replace with your Bitcoin address
    "password": "x",                    # Password (usually "x" or "password")
    "min_diff": 1,                      # Minimum difficulty (minimum is 1)
    "poll_sleep": 0.05,
    "reconnect_backoff": 5.0,
}
```

--------------------------------

### Start Mining (Random Extranonce2 + Random Nonce)

Source: https://github.com/dhmyess/pycudabtcminer/blob/main/README.md

Launches the Bitcoin miner using a random extranonce2 value and performing a random sampling of nonces. This method is recommended for all GPU types and is more efficient for medium-speed GPUs, trying 196,608,000 nonces per extranonce2 by default.

```bash
python3 random_miner.py
```

--------------------------------

### Compile CUDA Kernels (Windows)

Source: https://github.com/dhmyess/pycudabtcminer/blob/main/README.md

Compiles CUDA kernels for Bitcoin mining on Windows systems. This script generates dynamic-link libraries (.dll) required by the Python modules. Ensure you have the NVIDIA CUDA Toolkit installed and configured in your system's PATH.

```bash
build.bat
```

--------------------------------

### Adjust Random Nonce Sampling in CUDA Kernel (Example Increase)

Source: https://github.com/dhmyess/pycudabtcminer/blob/main/README.md

Example of increasing threads per block and blocks per grid in the CUDA kernel (`rr.cu`) to attempt more nonces per extranonce2. This configuration aims for a total of 524,288,000 nonces (1000 * 512 * 1024). Recompilation is required after modification.

```c++
int threadsPerBlock = 512;
int blocksPerGrid = 1024;
```

--------------------------------

### Compile CUDA Kernels (Linux)

Source: https://github.com/dhmyess/pycudabtcminer/blob/main/README.md

Compiles CUDA kernels for Bitcoin mining on Linux systems. This script generates shared objects (.so) required by the Python modules. It first makes the script executable and then runs it. Ensure you have the NVIDIA CUDA Toolkit installed and configured in your system's PATH.

```bash
chmod +x build.sh
./build.sh
```

--------------------------------

### Random Nonce Mining (Bash/Python)

Source: https://context7.com/dhmyess/pycudabtcminer/llms.txt

Runs the Bitcoin miner using a random nonce sampling approach, leveraging cuRAND for generating nonces. This method tests approximately 196 million random nonces per extranonce2 and is more efficient for medium-speed GPUs. Output includes authentication, difficulty, job updates, and details of found shares.

```bash
python3 random_miner.py

# Output:
# [+] Auth OK
# [+] Initial difficulty: 100000.00
# [+] Pool difficulty updated: 1.000000
# [+] New Job ID detected! Switching to job: 6978d6ba00000709
#    [i] 15 extranonce2 has been tried in 3.25 second
#   [✅] 14:32:45 Found Share!
#        Job ID: 6978d6ba00000709
#        EN2   : a3f82b1c
#        Nonce : 7f2e9ab4
#        Hash  : 00000000012abc...
#        Diff  : 185.42

```

--------------------------------

### Mining Configuration (Python)

Source: https://context7.com/dhmyess/pycudabtcminer/llms.txt

A Python dictionary defining the configuration parameters for the mining scripts. This includes pool connection details like address, port, user name (Bitcoin wallet address), password, and mining-specific settings such as minimum difficulty and polling intervals.

```python
config = {
    "pool_address": "public-pool.io",     # Mining pool hostname
    "pool_port": 3333,                     # Stratum port
    "user_name": "bc1qYOUR_ADDRESS_HERE", # Your Bitcoin wallet address
    "password": "x",                       # Pool password (usually "x")
    "min_diff": 1,                         # Minimum difficulty threshold
    "poll_sleep": 0.05,                    # Job polling interval (seconds)
    "reconnect_backoff": 5.0,              # Reconnection delay after errors
    "max_extranonce2": 0xFFFFFFFF          # Maximum extranonce2 value
}

```

--------------------------------

### Full Nonce Scan Mining (Bash/Python)

Source: https://context7.com/dhmyess/pycudabtcminer/llms.txt

Executes the Bitcoin miner using a full sequential scan of all possible nonce values (0x00000000 to 0xFFFFFFFF) via the CUDA kernel. This is suitable for high-hashrate GPUs. The output shows authentication status, difficulty updates, job detection, and found shares with nonce and hash details.

```bash
python3 miner.py

# Output:
# [+] Auth OK
# [+] Initial difficulty: 100000.00
# [+] Pool difficulty updated: 1.000000
# [+] New Job detected! ID: 6978d6ba00000709
# [>] Scanning Full Range (0-4G) | EN2: 755c8940...
#     Finished in 1.02s | Hashrate: 4211.73 MH/s
#   [✅] 02:16:09 Found Share!
#        Job ID: 6978d6ba00000709
#        Nonce : d0ee7abf
#        Hash  : 000000000fb1abc2d054395e4aaec12fb8c4d2d4a962056e4c656b6708b8c6
#        Diff  : 260.99

```

--------------------------------

### Run Testing and Benchmark Script

Source: https://github.com/dhmyess/pycudabtcminer/blob/main/README.md

Executes a Python script to test the functionality of CUDA mining kernels and benchmark the GPU's hashrate. This script uses a specific block (933,995) for testing and displays the time required for a full nonce scan.

```python
python3 test.py
```

--------------------------------

### Benchmark GPU Performance (Bash)

Source: https://context7.com/dhmyess/pycudabtcminer/llms.txt

The test.py script is used to benchmark the performance of the GPU mining implementation. It scans a real block header from block 934,235, measuring the hashrate and validating the CUDA kernel's functionality. The script outputs the number of valid shares found, nonce, blockhash, difficulty, elapsed time, and calculated hashrate.

```bash
python3 test.py

# Output:
# Starting mining scan (Full Range: 0 - 0xFFFFFFFF)...
# Please wait...
#
# ✅ Found 3 valid share(s)!
#
# --- Share #1 ---
# Nonce       : 393847263 (0x177a9a5f)
# Blockhash   : 00000000000000000000132e777589264ca2ffc47319ea55f8cbf6f180a7293d
# Difficulty  : 83129223894784.00
#
# ========================================
# Execution Stats:
# Elapsed Time : 1.0234 seconds
# Hashrate     : 4197.52 MH/s
# ========================================
```

--------------------------------

### Validate Genesis Block Mining (Bash)

Source: https://context7.com/dhmyess/pycudabtcminer/llms.txt

The test_block_genesis.py script verifies the CUDA kernel's correctness by using Bitcoin's genesis block header. This test ensures that the implementation can accurately find the original nonce for the genesis block, confirming the kernel's integrity. The output includes the number of shares found, nonce, blockhash, difficulty, elapsed time, and hashrate.

```bash
python3 test_block_genesis.py

# Output:
# Starting mining scan (Full Range: 0 - 0xFFFFFFFF)...
# Please wait...
#
# ✅ Found 1 valid share(s)!
#
# --- Share #1 ---
# Nonce       : 2083236893 (0x7c2bac1d)
# Blockhash   : 000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f
# Difficulty  : 1.00
#
# ========================================
# Execution Stats:
# Elapsed Time : 1.0156 seconds
# Hashrate     : 4229.13 MH/s
# ========================================
```

--------------------------------

### Sequential CUDA Kernel Interface (Python)

Source: https://context7.com/dhmyess/pycudabtcminer/llms.txt

Provides a Python interface to the sequential CUDA kernel for Bitcoin mining. The `looper.py` module preprocesses block headers, computes SHA-256 midstates, and calls the GPU function to perform a full nonce scan. It returns found nonces and block hashes, allowing for difficulty calculation.

```python
from looper import mining_nonce

# Block header (152 hex chars = 76 bytes without nonce)
hex_header = "00800220e8f33cff4a360027dbf6a0ffec523939b329a91ae58a01000000000000000000d67d87fef5331b8055007ca44082f38c63887a019352ca517332dc516fc2f6e5d2807b69a1fc0117"

# Target difficulty (pool difficulty)
pool_target = 1.0

# Execute full nonce scan (0 to 0xFFFFFFFF)
# Returns: list of tuples [(nonce, blockhash), ...]
found_shares = mining_nonce(hex_header, pool_target)

# Process results
if found_shares:
    for nonce, blockhash in found_shares:
        # Calculate share difficulty
        max_target = 0x00000000ffff0000000000000000000000000000000000000000000000000000
        difficulty = max_target / int(blockhash, 16)
        print(f"Nonce: {nonce:08x}, Difficulty: {difficulty:.2f}")

```

--------------------------------

### Compile CUDA Kernels (Bash/Batch)

Source: https://context7.com/dhmyess/pycudabtcminer/llms.txt

Scripts to compile CUDA kernels for PyCudaBTCMiner. These scripts automatically detect GPU compute capability and generate optimized shared libraries for Linux (.so) and Windows (.dll).

```bash
# Linux - compile CUDA kernels
chmod +x build.sh
./build.sh

# Output:
# --- Starting build process ---
# Detected GPU Compute Capability: 8.6
# Using nvcc architecture flag: -arch=sm_86
# --- Compilation successful! ---

```

```batch
# Windows - compile CUDA kernels
build.bat

# Generated files:
# Linux: rr.so, liblooper.so
# Windows: rr.dll, liblooper.dll

```

--------------------------------

### Stratum Client for Mining Pool Communication (Python)

Source: https://context7.com/dhmyess/pycudabtcminer/llms.txt

The StratumClient class facilitates TCP socket communication with mining pools using the Stratum protocol. It handles connection establishment, user authentication, receiving job notifications, and submitting found shares. Dependencies include the random_miner module for StratumClient and block header construction.

```python
from random_miner import StratumClient, build_block_header_from_job

# Connect to mining pool
client = StratumClient("public-pool.io", 3333)

# Authenticate with pool
client.login("bc1qYOUR_ADDRESS", "x")
# client.extranonce1 = "08000002"  # Assigned by pool
# client.extranonce2_size = 4      # Bytes for extranonce2

# Poll for new jobs and difficulty updates
messages = client.poll_message()
for msg in messages:
    if msg.get("method") == "mining.notify":
        job = msg["params"]
        # job[0] = job_id
        # job[1] = prevhash
        # job[2] = coinb1
        # job[3] = coinb2
        # job[4] = merkle_branch
        # job[5] = version
        # job[6] = nbits
        # job[7] = ntime
        # job[8] = clean_jobs flag

    elif msg.get("method") == "mining.set_difficulty":
        difficulty = float(msg["params"][0])

# Build block header from job
extranonce2 = "00000001"
job_id, header_hex = build_block_header_from_job(
    job, client.extranonce1, extranonce2
)

# Submit found share
client.send("mining.submit", [
    "bc1qYOUR_ADDRESS",  # username
    job_id,              # job id
    extranonce2,         # extranonce2
    job[7],              # ntime
    "1dac2b7c"          # nonce (hex)
])

# Clean up
client.close()
```

--------------------------------

### Configure CUDA Kernel Parameters (C++)

Source: https://context7.com/dhmyess/pycudabtcminer/llms.txt

Sets thread and block configurations for CUDA kernels. The sequential kernel uses larger batches, while the random kernel balances memory usage for cuRAND states. Adjust values based on GPU capabilities to balance memory usage and throughput.

```c++
// liblooper.cu - Sequential scan configuration
int threadsPerBlock = 256;
int blocksPerGrid = 65536;
// Total: 256 * 65536 = 16,777,216 threads per batch
// Full scan: 4,294,967,295 / 16,777,216 = ~256 batch iterations

// rr.cu - Random nonce configuration
int threadsPerBlock = 320;
int blocksPerGrid = 320;
// Total threads: 320 * 320 = 102,400
// Loop iterations: 2000
// Nonces per call: 102,400 * 2000 = 204,800,000

// Adjust for your GPU:
// Higher values = more GPU memory usage, potentially better throughput
// Lower values = less memory, may be needed for older GPUs
```

--------------------------------

### Generate Random Nonces with CUDA (Python)

Source: https://context7.com/dhmyess/pycudabtcminer/llms.txt

The rrnonce.py module interfaces with a CUDA kernel to generate random nonces for Bitcoin mining. It utilizes cuRAND for random number generation, sampling approximately 196 million nonces per call. The function takes a hex-encoded block header and a pool target difficulty as input, returning a list of valid (nonce, blockhash) tuples.

```python
from rrnonce import mining_nonce

# Block header without nonce
hex_header = "00800220e8f33cff4a360027dbf6a0ffec523939b329a91ae58a01000000000000000000d67d87fef5331b8055007ca44082f38c63887a019352ca517332dc516fc2f6e5d2807b69a1fc0117"

# Target difficulty
pool_target = 1.0

# Execute random nonce sampling
# Internally uses time-based seed for RNG initialization
# Samples ~196M random nonces (320 threads * 320 blocks * 2000 iterations)
found_shares = mining_nonce(hex_header, pool_target)

# Results are list of (nonce, blockhash) tuples
for nonce, blockhash in found_shares:
    print(f"Found valid nonce: 0x{nonce:08x}")
```

--------------------------------

### Adjust Random Nonce Sampling in CUDA Kernel (C/C++)

Source: https://github.com/dhmyess/pycudabtcminer/blob/main/README.md

Modifies the CUDA kernel source code (`rr.cu`) to adjust the number of threads per block and blocks per grid for random nonce sampling. Increasing these values increases the total number of nonces attempted per extranonce2, potentially improving hash rate on powerful GPUs. Remember to recompile the kernel after making changes.

```c++
int threadsPerBlock = 256;  // Threads per block
int blocksPerGrid = 768;    // Blocks per grid
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.