HashCore Toolkit uses a local-first architecture that prioritizes performance, security, and ease of deployment. Understand the system design behind efficient ASIC fleet management.
This page explains how HashCore discovers devices, communicates with miners, stores data, and scales to manage thousands of devices efficiently.
Local-First Architecture
Runs on your network without cloud dependencies
HashCore Toolkit operates as a local application that runs on a single machine within your mining network. This machine acts as the management server, communicating directly with ASIC miners over the local network.
Unlike cloud-based management platforms, HashCore does not require data to leave your facility. All monitoring data, configuration settings, and operational history remain under your control. This approach improves security, reduces latency, and ensures management capabilities continue functioning even if internet connectivity is lost.
The local-first design means you can deploy HashCore in air-gapped environments or facilities with limited internet access. For operations requiring remote access, secure tunneling can be configured without exposing the internal network.
Device Discovery Process
Automatic detection of ASIC miners on the network
HashCore automatically discovers ASIC miners by scanning specified IP ranges or using network broadcast protocols. When a miner is detected, HashCore identifies the model, firmware version, and current configuration.
Discovery Methods
1.
IP Range Scanning: Scan specific subnet ranges (e.g., 192.168.1.0/24) to find miners
2.
Network Broadcast: Use mDNS or UPnP protocols to detect miners automatically
3.
Manual Addition: Add specific IP addresses for miners with static assignments
4.
Import from CSV: Bulk import device lists with IP and credential information
Once discovered, devices are added to the management dashboard where they can be organized into groups, labeled by location or purpose, and monitored continuously. Discovery runs periodically to detect new devices or changes in the network.
Communication with Miners
How HashCore interacts with ASIC devices
HashCore communicates with ASIC miners using standard protocols including CGMiner API and manufacturer-specific web APIs. These protocols allow reading status information, modifying configuration, and executing commands like restart or shutdown.
Supported Communication Methods
•
CGMiner API: JSON-RPC interface for reading hashrate, temperature, and diagnostics
•
HTTP/HTTPS APIs: Manufacturer web interfaces for configuration changes
•
SSH: Direct system access for advanced diagnostics and firmware deployment
HashCore maintains persistent connections to monitored devices, polling for status updates at configurable intervals (typically 30-60 seconds). This provides near real-time visibility without overwhelming network bandwidth.
For bulk operations affecting hundreds of devices simultaneously, HashCore implements intelligent batching and rate limiting to prevent network congestion. Operations are queued and executed in parallel threads up to a configurable concurrency limit.
Data Storage and Management
How operational data is stored and accessed
HashCore stores operational data in a local database on the management server. This includes device inventory, configuration history, performance metrics, and audit logs.
Stored Information
•Device inventory with hardware details and network information
•Historical performance data (hashrate, temperature, power consumption)
•Configuration templates and deployment history
•User accounts, permissions, and audit logs
•Alert rules and notification preferences
Time-series data like hashrate and temperature is retained with configurable retention policies. Aggregated summaries preserve long-term trends while managing storage requirements. Detailed logs can be exported for external analysis or compliance requirements.
Database files can be backed up using standard file backup tools. For high-availability scenarios, the entire HashCore installation can be replicated to a standby server with near-instant failover capability.
Scalability and Performance
HashCore Toolkit is designed to manage up to 50,000 devices from a single instance. This capacity assumes a properly sized management server with adequate CPU, memory, and network connectivity.
For operations exceeding 50,000 devices or requiring geographic distribution, multiple HashCore instances can be deployed with centralized oversight through HashCore Pulse. This architecture supports millions of devices across multiple sites.
Recommended Server Specifications
Up to 1,000 Devices
• 4 CPU cores
• 8 GB RAM
• 50 GB storage
• 1 Gbps network
Up to 50,000 Devices
• 16+ CPU cores
• 32+ GB RAM
• 500 GB storage
• 10 Gbps network
See the installation guide for detailed hardware requirements and deployment recommendations based on your fleet size.
Ready to deploy HashCore Toolkit in your environment?