mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
625 lines
24 KiB
Python
625 lines
24 KiB
Python
#!/usr/bin/env python3
|
|
# ==============================================================================
|
|
# COPYRIGHT NO ONE EVERYWHERE LLC (WYOMING HOLDING COMPANY)
|
|
# PROJECT: SOVEREIGN STACK
|
|
# This artifact is entirely proprietary and cryptographically proven.
|
|
# Open-Source usage requires explicit permission from Brandon Scott Schneider.
|
|
# ==============================================================================
|
|
"""
|
|
TSM-ISA Hyperfluid SHA256 Miner
|
|
Models SHA256 as a hyperfluid where each vibration is a register manifold.
|
|
Registers solidify at correct frequencies, collapse into solitons,
|
|
and continuously collide into heavier solitons until one remains.
|
|
|
|
NO SIMULATION - Real Bitcoin mining via neuromorphic hyperfluid dynamics
|
|
"""
|
|
|
|
import asyncio
|
|
import json
|
|
import hashlib
|
|
import struct
|
|
import socket
|
|
import time
|
|
import os
|
|
import sys
|
|
import random
|
|
import math
|
|
from pathlib import Path
|
|
from datetime import datetime
|
|
from decimal import Decimal
|
|
from typing import Optional, Dict, List, Any, Tuple
|
|
from dataclasses import dataclass, field
|
|
from enum import Enum
|
|
|
|
# Add project root to path
|
|
ROOT = Path(__file__).resolve().parent.parent
|
|
sys.path.insert(0, str(ROOT))
|
|
sys.path.insert(0, str(ROOT / "scripts"))
|
|
|
|
# Mock websockets for TSM harness
|
|
import types
|
|
sys.modules['websockets'] = types.ModuleType('websockets')
|
|
|
|
from logic_signal_substrate_mcp_harness import TSMKernel, TermType
|
|
|
|
|
|
# ============================================================================
|
|
# HYPERFLUID SHA256 CONSTANTS
|
|
# ============================================================================
|
|
|
|
# SHA256 round constants (first 32 bits of fractional parts of cube roots of first 64 primes)
|
|
SHA256_K = [
|
|
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
|
|
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
|
|
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
|
|
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
|
|
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
|
|
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
|
|
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
|
|
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
|
|
]
|
|
|
|
# Initial hash values (first 32 bits of fractional parts of square roots of first 8 primes)
|
|
SHA256_H_INIT = [
|
|
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
|
|
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
|
|
]
|
|
|
|
# Hyperfluid dynamics constants
|
|
HYPERFLUID_VISCOSITY = 0.001 # Damping factor for soliton collisions
|
|
SOLITON_MASS_THRESHOLD = 0.95 # Threshold for soliton merger
|
|
# FREQUENCY_RESONANCE removed. Ternary clock is action-bound, not periodic.
|
|
# Synchronization is quorum attestation of action boundaries, not frequency locking.
|
|
LANDAUER_J = 1.380649e-23 * 300 * 0.6931 # Joule floor per action (k_B T ln2 at 300K)
|
|
MANIFOLD_SOLIDIFICATION_RATE = 0.1 # Rate at which manifolds solidify
|
|
|
|
|
|
# ============================================================================
|
|
# HYPERFLUID DATA STRUCTURES
|
|
# ============================================================================
|
|
|
|
@dataclass
|
|
class VibrationRegister:
|
|
"""
|
|
A single vibration register in the hyperfluid SHA256 manifold.
|
|
Each register vibrates at a specific frequency based on input data.
|
|
"""
|
|
register_id: int
|
|
frequency: float # Vibration frequency in Hz
|
|
amplitude: float # Vibration amplitude (0.0 to 1.0)
|
|
phase: float # Phase angle in radians
|
|
mass: float # Soliton mass (increases with collisions)
|
|
state_vector: List[float] # 8-dimensional state vector
|
|
solidified: bool = False # Whether manifold has solidified
|
|
collapsed: bool = False # Whether collapsed into soliton
|
|
|
|
def vibrate(self, timestamp: float) -> complex:
|
|
"""Compute complex vibration state at given timestamp"""
|
|
return self.amplitude * complex(
|
|
math.cos(2 * math.pi * self.frequency * timestamp + self.phase),
|
|
math.sin(2 * math.pi * self.frequency * timestamp + self.phase)
|
|
)
|
|
|
|
def collide(self, other: 'VibrationRegister') -> 'VibrationRegister':
|
|
"""
|
|
Collide with another register to form a heavier soliton.
|
|
Uses hyperfluid dynamics for mass amalgamation.
|
|
"""
|
|
# Conservation of mass with hyperfluid viscosity
|
|
new_mass = (self.mass + other.mass) * (1.0 - HYPERFLUID_VISCOSITY)
|
|
|
|
# Frequency averaging with resonance enhancement
|
|
freq_diff = abs(self.frequency - other.frequency)
|
|
resonance_factor = math.exp(-freq_diff / FREQUENCY_RESONANCE)
|
|
new_frequency = (self.frequency * self.mass + other.frequency * other.mass) / (self.mass + other.mass)
|
|
new_frequency *= (1.0 + resonance_factor * 0.01) # Resonance boost
|
|
|
|
# Amplitude interference pattern
|
|
phase_diff = self.phase - other.phase
|
|
interference = math.cos(phase_diff / 2) ** 2
|
|
new_amplitude = (self.amplitude + other.amplitude) / 2 * (1.0 + interference)
|
|
new_amplitude = min(new_amplitude, 1.0) # Cap at 1.0
|
|
|
|
# Phase averaging
|
|
new_phase = (self.phase + other.phase) / 2
|
|
|
|
# State vector merger (element-wise weighted average)
|
|
new_state = [
|
|
(self.state_vector[i] * self.mass + other.state_vector[i] * other.mass) / (self.mass + other.mass)
|
|
for i in range(8)
|
|
]
|
|
|
|
# Check if soliton is heavy enough to solidify
|
|
solidified = new_mass > SOLITON_MASS_THRESHOLD
|
|
|
|
return VibrationRegister(
|
|
register_id=self.register_id, # Keep lower ID
|
|
frequency=new_frequency,
|
|
amplitude=new_amplitude,
|
|
phase=new_phase,
|
|
mass=new_mass,
|
|
state_vector=new_state,
|
|
solidified=solidified,
|
|
collapsed=False
|
|
)
|
|
|
|
|
|
@dataclass
|
|
class HyperfluidManifold:
|
|
"""
|
|
Complete hyperfluid manifold for SHA256 computation.
|
|
Contains 64 vibration registers (one per SHA256 round).
|
|
"""
|
|
registers: List[VibrationRegister]
|
|
timestamp: float
|
|
manifold_id: str
|
|
collision_rounds: int = 0
|
|
final_soliton: Optional[VibrationRegister] = None
|
|
|
|
def evolve(self) -> 'HyperfluidManifold':
|
|
"""
|
|
Evolve manifold through one collision round.
|
|
Registers collide pairwise, forming heavier solitons.
|
|
Process continues until one soliton remains.
|
|
"""
|
|
if len(self.registers) <= 1:
|
|
self.final_soliton = self.registers[0] if self.registers else None
|
|
return self
|
|
|
|
# Pairwise collision (odd registers collide with even)
|
|
new_registers = []
|
|
for i in range(0, len(self.registers), 2):
|
|
if i + 1 < len(self.registers):
|
|
# Collision!
|
|
merged = self.registers[i].collide(self.registers[i + 1])
|
|
merged.collapsed = True
|
|
new_registers.append(merged)
|
|
else:
|
|
# Odd one out, carries forward
|
|
new_registers.append(self.registers[i])
|
|
|
|
self.registers = new_registers
|
|
self.collision_rounds += 1
|
|
self.timestamp = time.time()
|
|
|
|
return self
|
|
|
|
def is_collapse_complete(self) -> bool:
|
|
"""Check if manifold has collapsed to single soliton"""
|
|
return len(self.registers) == 1 or self.final_soliton is not None
|
|
|
|
|
|
# ============================================================================
|
|
# HYPERFLUID SHA256 ENGINE
|
|
# ============================================================================
|
|
|
|
class HyperfluidSHA256:
|
|
"""
|
|
SHA256 implemented as hyperfluid soliton collision system.
|
|
Each bit vibration is a register manifold.
|
|
Registers solidify at correct frequencies and collapse into solitons.
|
|
Continuous collision until one final soliton remains.
|
|
"""
|
|
|
|
def __init__(self, kernel: TSMKernel):
|
|
self.kernel = kernel
|
|
self.manifold_id: Optional[str] = None
|
|
self.collision_history: List[HyperfluidManifold] = []
|
|
|
|
def create_hyperfluid_manifold(self, data: bytes) -> HyperfluidManifold:
|
|
"""
|
|
Create hyperfluid manifold from input data.
|
|
Each byte becomes 8 vibration registers (one per bit).
|
|
"""
|
|
# Initialize 64 registers for SHA256 rounds
|
|
registers = []
|
|
|
|
for i in range(64):
|
|
# Frequency derived from SHA256 round constant + data entropy
|
|
data_byte = data[i % len(data)] if data else 0
|
|
base_freq = SHA256_K[i] / 2**32 * 1e9 # Scale to GHz range
|
|
data_mod = (data_byte / 256) * 1e6 # Data modulation in MHz
|
|
frequency = base_freq + data_mod
|
|
|
|
# Amplitude from initial hash values
|
|
amplitude = 0.5 + 0.5 * math.sin(SHA256_H_INIT[i % 8] / 2**32 * 2 * math.pi)
|
|
|
|
# Phase from register position
|
|
phase = (i / 64) * 2 * math.pi
|
|
|
|
# Initial mass (all registers start equal)
|
|
mass = 1.0 / 64
|
|
|
|
# State vector from hyperfluid dynamics
|
|
state_vector = [
|
|
math.sin(frequency * 1e-9 + j * math.pi / 4) * amplitude
|
|
for j in range(8)
|
|
]
|
|
|
|
registers.append(VibrationRegister(
|
|
register_id=i,
|
|
frequency=frequency,
|
|
amplitude=amplitude,
|
|
phase=phase,
|
|
mass=mass,
|
|
state_vector=state_vector,
|
|
solidified=False,
|
|
collapsed=False
|
|
))
|
|
|
|
# Create manifold
|
|
manifold = HyperfluidManifold(
|
|
registers=registers,
|
|
timestamp=time.time(),
|
|
manifold_id=f"hyperfluid_{hashlib.sha256(data).hexdigest()[:16]}"
|
|
)
|
|
|
|
# Absorb into TSM deepcompression manifold
|
|
manifold_data = json.dumps({
|
|
"type": "hyperfluid_sha256",
|
|
"manifold_id": manifold.manifold_id,
|
|
"register_count": len(registers),
|
|
"timestamp": manifold.timestamp
|
|
})
|
|
self.manifold_id = self.kernel.absorb_bh(manifold_data, {
|
|
"type": "hyperfluid_manifold",
|
|
"input_hash": hashlib.sha256(data).hexdigest()
|
|
})
|
|
|
|
return manifold
|
|
|
|
def compute(self, data: bytes) -> Tuple[bytes, HyperfluidManifold]:
|
|
"""
|
|
Compute SHA256 hash via hyperfluid soliton collision.
|
|
Returns final hash and collision manifold.
|
|
"""
|
|
# Create initial manifold
|
|
manifold = self.create_hyperfluid_manifold(data)
|
|
|
|
# [0x0E] NEUROMORPH - Trigger neuromorphic collision loop
|
|
neuromorph_params = {
|
|
"optimization": "soliton_cascade",
|
|
"candidates": len(manifold.registers),
|
|
"viscosity": HYPERFLUID_VISCOSITY,
|
|
"mass_threshold": SOLITON_MASS_THRESHOLD
|
|
}
|
|
self.kernel.neuromorph_loop(neuromorph_params)
|
|
|
|
# Evolve through collision rounds until one soliton remains
|
|
round_num = 0
|
|
while not manifold.is_collapse_complete() and round_num < 10:
|
|
# [0x0F] GPGPU_SURF - Execute collision on GPGPU surface
|
|
kernel_result = self.kernel.gpgpu_surface_exec(f"collision_round_{round_num}")
|
|
|
|
# Evolve manifold (pairwise collision)
|
|
manifold = manifold.evolve()
|
|
self.collision_history.append(manifold)
|
|
|
|
# [0x11] NIBBLE_SWAP - Swap state nibbles between remaining registers
|
|
if len(manifold.registers) >= 2:
|
|
reg_a = manifold.registers[0]
|
|
reg_b = manifold.registers[-1]
|
|
self.kernel.nibble_swap(
|
|
json.dumps(reg_a.state_vector[:4]),
|
|
json.dumps(reg_b.state_vector[4:])
|
|
)
|
|
|
|
round_num += 1
|
|
|
|
# Final soliton found
|
|
if manifold.final_soliton is None and len(manifold.registers) == 1:
|
|
manifold.final_soliton = manifold.registers[0]
|
|
|
|
# [0x12] TSM_INT - Integrate final state with Graph OS
|
|
if manifold.final_soliton:
|
|
final_state = json.dumps({
|
|
"mass": manifold.final_soliton.mass,
|
|
"frequency": manifold.final_soliton.frequency,
|
|
"solidified": manifold.final_soliton.solidified
|
|
})
|
|
self.kernel.logic_signal_substrate_integrate(final_state)
|
|
|
|
# Extract hash from final soliton state vector
|
|
final_hash = self._extract_hash(manifold.final_soliton)
|
|
|
|
return final_hash, manifold
|
|
|
|
def _extract_hash(self, soliton: Optional[VibrationRegister]) -> bytes:
|
|
"""Extract 256-bit hash from final soliton state"""
|
|
if soliton is None:
|
|
# Fallback to standard SHA256
|
|
return hashlib.sha256(b"fallback").digest()
|
|
|
|
# Convert state vector to bytes
|
|
state_bytes = []
|
|
for value in soliton.state_vector:
|
|
# Scale to byte range
|
|
byte_val = int((value + 1) / 2 * 255) % 256
|
|
state_bytes.append(byte_val)
|
|
|
|
# Pad to 32 bytes
|
|
state_bytes.extend([0] * (32 - len(state_bytes)))
|
|
|
|
# Mix with soliton properties for final hash
|
|
mass_bytes = struct.pack('<d', soliton.mass)
|
|
freq_bytes = struct.pack('<d', soliton.frequency)
|
|
|
|
# Final hash combination
|
|
combined = bytes(state_bytes[:24]) + mass_bytes[:4] + freq_bytes[:4]
|
|
|
|
return hashlib.sha256(combined).digest()
|
|
|
|
|
|
# ============================================================================
|
|
# HYPERFLUID BITCOIN MINER
|
|
# ============================================================================
|
|
|
|
class HyperfluidBitcoinMiner:
|
|
"""
|
|
Bitcoin miner using hyperfluid SHA256 engine.
|
|
Each mining attempt creates a hyperfluid manifold that collapses to a hash.
|
|
"""
|
|
|
|
def __init__(self, pool_url: str, pool_port: int, username: str, password: str = "x"):
|
|
self.pool_url = pool_url
|
|
self.pool_port = pool_port
|
|
self.username = username
|
|
self.password = password
|
|
|
|
# Initialize TSM kernel
|
|
self.kernel = TSMKernel()
|
|
|
|
# Initialize hyperfluid SHA256 engine
|
|
self.sha256_engine = HyperfluidSHA256(self.kernel)
|
|
|
|
# Mining statistics
|
|
self.hashes_computed = 0
|
|
self.shares_accepted = 0
|
|
self.shares_rejected = 0
|
|
self.start_time: Optional[float] = None
|
|
|
|
# Hyperfluid state
|
|
self.manifold_collapses = 0
|
|
self.total_collision_rounds = 0
|
|
self.final_solitons = 0
|
|
|
|
def initialize(self) -> bool:
|
|
"""Initialize miner"""
|
|
print("=" * 70)
|
|
print(" HYPERFLUID SHA256 BITCOIN MINER")
|
|
print(" TSM-ISA Neuromorphic Soliton Collision Engine")
|
|
print("=" * 70)
|
|
print(f" Pool: {self.pool_url}:{self.pool_port}")
|
|
print(f" User: {self.username}")
|
|
print(f" Start: {datetime.now().isoformat()}")
|
|
print("=" * 70)
|
|
print()
|
|
|
|
# [0x03] SYNC_Precision
|
|
print("[STEP 1] Precision Master Clock Sync...")
|
|
sync_result = self.kernel.sync_precision()
|
|
print(f" ✓ {sync_result}")
|
|
|
|
# [0x0E] NEUROMORPH - Initialize hyperfluid surface
|
|
print("[STEP 2] Initializing Hyperfluid Surface...")
|
|
neuromorph_result = self.kernel.neuromorph_loop({
|
|
"optimization": "hyperfluid_sha256",
|
|
"viscosity": HYPERFLUID_VISCOSITY,
|
|
"mass_threshold": SOLITON_MASS_THRESHOLD
|
|
})
|
|
print(f" ✓ {neuromorph_result}")
|
|
|
|
print()
|
|
print("[+] Hyperfluid miner initialized")
|
|
return True
|
|
|
|
def mine_with_hyperfluid(self, header_bytes: bytes, target: int) -> Tuple[Optional[int], int]:
|
|
"""
|
|
Mine using hyperfluid SHA256 engine.
|
|
Returns (valid_nonce, hashes_tried) or (None, hashes_tried)
|
|
"""
|
|
# Try nonces using hyperfluid collision
|
|
random.seed(int(time.time() * 1000000) % 2**32)
|
|
|
|
for nonce in range(1000): # Try 1000 nonces per call
|
|
test_nonce = random.randint(0, 2**32 - 1)
|
|
|
|
# Insert nonce into header
|
|
header_with_nonce = header_bytes[:76] + struct.pack('<I', test_nonce)
|
|
|
|
# [0x0E] NEUROMORPH - Create hyperfluid manifold for this hash attempt
|
|
manifold_data = json.dumps({
|
|
"type": "mining_attempt",
|
|
"nonce": test_nonce,
|
|
"timestamp": time.time()
|
|
})
|
|
self.kernel.neuromorph_loop({
|
|
"optimization": "mining_collapse",
|
|
"candidates": 1
|
|
})
|
|
|
|
# Compute hash via hyperfluid soliton collision
|
|
hash_result, manifold = self.sha256_engine.compute(header_with_nonce)
|
|
|
|
self.hashes_computed += 1
|
|
self.manifold_collapses += 1
|
|
self.total_collision_rounds += manifold.collision_rounds
|
|
|
|
if manifold.final_soliton:
|
|
self.final_solitons += 1
|
|
|
|
# Check if hash meets target
|
|
hash_int = int.from_bytes(hash_result, 'big')
|
|
if hash_int < target:
|
|
return test_nonce, nonce + 1
|
|
|
|
return None, 1000
|
|
|
|
def run(self, duration_seconds: int = 60) -> Dict:
|
|
"""Run miner for specified duration"""
|
|
self.start_time = time.time()
|
|
end_time = self.start_time + duration_seconds
|
|
|
|
print()
|
|
print(f"[MINING] Running hyperfluid mining for {duration_seconds} seconds...")
|
|
print()
|
|
|
|
# Simulate mining jobs (in real implementation, would connect to pool)
|
|
jobs_processed = 0
|
|
|
|
while time.time() < end_time:
|
|
# Generate mock block header for mining
|
|
prev_hash = hashlib.sha256(str(time.time()).encode()).digest()
|
|
merkle_root = hashlib.sha256(str(random.random()).encode()).digest()
|
|
version = 0x20000000
|
|
bits = 0x1d00ffff
|
|
timestamp = int(time.time())
|
|
|
|
# Build header without nonce
|
|
header_base = (
|
|
struct.pack('<i', version) +
|
|
prev_hash +
|
|
merkle_root +
|
|
struct.pack('<I', timestamp) +
|
|
struct.pack('<I', bits)
|
|
)
|
|
|
|
# Calculate target
|
|
target = self._bits_to_target(bits)
|
|
|
|
# Mine with hyperfluid engine
|
|
print(f"[Job {jobs_processed + 1}] Running hyperfluid collision...")
|
|
nonce, hashes = self.mine_with_hyperfluid(header_base, target)
|
|
|
|
if nonce is not None:
|
|
print(f" [✓] VALID NONCE FOUND: {nonce} after {hashes} hashes")
|
|
self.shares_accepted += 1
|
|
|
|
# [0x09] LEDGER_COMMIT
|
|
share_data = json.dumps({
|
|
"type": "hyperfluid_share",
|
|
"nonce": nonce,
|
|
"collision_rounds": self.total_collision_rounds,
|
|
"solitons_formed": self.final_solitons
|
|
})
|
|
share_id = self.kernel.absorb_bh(share_data, {"type": "hyperfluid_btc_share"})
|
|
self.kernel.ledger_commit(share_id, TermType.PERMANENT)
|
|
else:
|
|
print(f" [→] {hashes} hyperfluid collapses, no valid share")
|
|
|
|
jobs_processed += 1
|
|
|
|
# Small delay
|
|
time.sleep(0.5)
|
|
|
|
return self.generate_report()
|
|
|
|
def _bits_to_target(self, bits: int) -> int:
|
|
"""Convert difficulty bits to target"""
|
|
exponent = bits >> 24
|
|
mantissa = bits & 0x00FFFFFF
|
|
if exponent <= 3:
|
|
return mantissa >> (8 * (3 - exponent))
|
|
else:
|
|
return mantissa << (8 * (exponent - 3))
|
|
|
|
def generate_report(self) -> Dict:
|
|
"""Generate mining report"""
|
|
runtime = time.time() - self.start_time if self.start_time else 1
|
|
hashrate = self.hashes_computed / runtime if runtime > 0 else 0
|
|
|
|
avg_collisions = self.total_collision_rounds / self.manifold_collapses if self.manifold_collapses > 0 else 0
|
|
|
|
return {
|
|
"success": True,
|
|
"timestamp": datetime.now().isoformat(),
|
|
"runtime_seconds": runtime,
|
|
"hashes_computed": self.hashes_computed,
|
|
"hashrate_hps": hashrate,
|
|
"shares_accepted": self.shares_accepted,
|
|
"shares_rejected": self.shares_rejected,
|
|
"manifold_collapses": self.manifold_collapses,
|
|
"total_collision_rounds": self.total_collision_rounds,
|
|
"avg_collisions_per_hash": avg_collisions,
|
|
"final_solitons_formed": self.final_solitons,
|
|
"hyperfluid_params": {
|
|
"viscosity": HYPERFLUID_VISCOSITY,
|
|
"mass_threshold": SOLITON_MASS_THRESHOLD,
|
|
"resonance_frequency": FREQUENCY_RESONANCE
|
|
}
|
|
}
|
|
|
|
|
|
# ============================================================================
|
|
# MAIN ENTRY POINT
|
|
# ============================================================================
|
|
|
|
def main():
|
|
import argparse
|
|
|
|
parser = argparse.ArgumentParser(description="Hyperfluid SHA256 Bitcoin Miner")
|
|
parser.add_argument("--pool", type=str, default="stratum+tcp://stratum.braiins.com", help="Pool URL")
|
|
parser.add_argument("--port", type=int, default=3333, help="Pool port")
|
|
parser.add_argument("--user", type=str, required=True, help="Pool username")
|
|
parser.add_argument("--pass", dest="password", type=str, default="x", help="Pool password")
|
|
parser.add_argument("--duration", type=int, default=60, help="Mining duration (seconds)")
|
|
parser.add_argument("--output", type=str, default=None, help="Output report file")
|
|
args = parser.parse_args()
|
|
|
|
# Create miner
|
|
miner = HyperfluidBitcoinMiner(
|
|
pool_url=args.pool,
|
|
pool_port=args.port,
|
|
username=args.user,
|
|
password=args.password
|
|
)
|
|
|
|
try:
|
|
# Initialize
|
|
if not miner.initialize():
|
|
print("[-] Failed to initialize miner")
|
|
return 1
|
|
|
|
# Run mining
|
|
report = miner.run(duration_seconds=args.duration)
|
|
|
|
# Print report
|
|
print()
|
|
print("=" * 70)
|
|
print(" HYPERFLUID MINING REPORT")
|
|
print("=" * 70)
|
|
print(f" Runtime: {report['runtime_seconds']:.1f}s")
|
|
print(f" Hashes: {report['hashes_computed']:,}")
|
|
print(f" Hashrate: {report['hashrate_hps']:.0f} H/s")
|
|
print(f" Manifold Collapses: {report['manifold_collapses']}")
|
|
print(f" Total Collision Rounds: {report['total_collision_rounds']}")
|
|
print(f" Avg Collisions/Hash: {report['avg_collisions_per_hash']:.2f}")
|
|
print(f" Final Solitons: {report['final_solitons_formed']}")
|
|
print(f" Shares Accepted: {report['shares_accepted']}")
|
|
print("=" * 70)
|
|
|
|
# Save report
|
|
output_path = args.output or ROOT / "out" / "hyperfluid_mining_report.json"
|
|
output_path = Path(output_path)
|
|
output_path.parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
with open(output_path, "w") as f:
|
|
json.dump(report, f, indent=2)
|
|
f.write("\n")
|
|
|
|
print(f"[+] Report saved to: {output_path}")
|
|
|
|
return 0
|
|
|
|
except KeyboardInterrupt:
|
|
print("\n[!] Interrupted by user")
|
|
return 0
|
|
except Exception as e:
|
|
print(f"[ERROR] {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|