SGP Crypto Mine

Setup Guide

Complete Setup Guide: Duino-Coin Mining with ESP32-C3 & Web Dashboard

Follow these steps to create your own mining farm and visualize it on the Bitcoin-themed dashboard.

PART 1: Hardware Setup (ESP32-C3)

Requirements

ESP32-C3 development board(s) (e.g., SuperMini, Xiao, NodeMCU).
USB-C or Micro-USB data cable.
PC running Windows, Mac, or Linux.

Step 1: Prepare Arduino IDE

Download and install Arduino IDE from arduino.cc.
Open Arduino IDE and go to File > Preferences.
In "Additional Board Manager URLs", paste this link:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Go to Tools > Board > Boards Manager.
Search for "esp32" and install the latest version of esp32 by Espressif Systems.

Step 2: Configure and Upload Code

Copy the code from the Code button () in the toolbar.
Paste it into a new sketch in Arduino IDE.
Modify the configuration lines at the beginning of the file:

const char* SSID        = "YOUR_WIFI_NAME";
const char* PASSWORD    = "YOUR_WIFI_PASSWORD";
const char* DUCO_USER   = "YOUR_DUCO_USER";
const char* RIG_IDENTIFIER = "ESP32-C3-01";

Connect your ESP32-C3 to the PC.
In Arduino IDE, go to Tools > Board and select your model (e.g., "ESP32C3 Dev Module").
Select the correct COM port in Tools > Port.
(Note: For SuperMini boards, hold BOOT button while plugging in if port doesn't appear).
Click the arrow button (➡️) Upload.
Open the Serial Monitor (115200 baud) to verify connection.

PART 2: Web Dashboard Setup

Option A: Use in this environment (Canvas)

Simply view the file in the editor on the right.
Click the Preview button to open the web app.
Use simulation modes immediately.

Option B: Run on your own PC (React)

Install Node.js.
Create project: npx create-react-app duco-dashboard
Install icons: npm install lucide-react
Replace src/App.js content with this code.
Run: npm start

PART 3: Final Connection (Real Data)

Once your ESP32-C3s are running (Serial Monitor says "Accepted").
In this Web App, enter your Duino-Coin username in the top input field.
Click the "Connect Real API" button.
You will see your ESP32s appear in the list with their real hashrate!

Troubleshooting

ESP32 won't connect to WiFi: Verify it is a 2.4GHz network.
Miners don't show up: It takes ~2 minutes for the API to report new miners.

Firmware Code

/*
  DUINO-COIN ESP32-C3 MINER - FIRMWARE v3.0
  This code connects your ESP32-C3 to the Duino-Coin pool.
  
  INSTRUCTIONS:
  1. Install Arduino IDE.
  2. Install ESP32 board support.
  3. Edit the SSID, PASSWORD, and DUCO_USER variables below.
  4. Upload the code to your board.
*/

#include <WiFi.h>
#include <WiFiClient.h>
#include "mbedtls/sha1.h"

// --- USER CONFIGURATION ---
const char* SSID        = "YOUR_WIFI_NAME";         // Your WiFi SSID
const char* PASSWORD    = "YOUR_WIFI_PASSWORD";     // Your WiFi Password
const char* DUCO_USER   = "YOUR_DUCO_USER";         // Your Duino-Coin username
const char* RIG_IDENTIFIER = "ESP32-C3-01";         // Unique name for this miner (e.g., Node-01)

// --- SYSTEM CONFIGURATION ---
const char* POOL_URL    = "server.duinocoin.com"; // Official Pool
const int   POOL_PORT   = 2813;
const int   LED_PIN     = 8; // On ESP32-C3 (SuperMini) LED is usually 8, on others it might be 2.

WiFiClient client;
String JOB_DIFFICULTY = "";

void setup() {
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);
  
  // 1. WiFi Connection
  Serial.println("\n\n[BOOT] Starting DUCO Miner ESP32-C3...");
  WiFi.begin(SSID, PASSWORD);
  
  Serial.print("[WIFI] Connecting to ");
  Serial.print(SSID);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    digitalWrite(LED_PIN, !digitalRead(LED_PIN)); // Blink while connecting
  }
  
  digitalWrite(LED_PIN, LOW); // LED off (or on depending on board) when connected
  Serial.println("\n[WIFI] Connected! IP: " + WiFi.localIP().toString());
}

// SHA1 Hashing Function (Mining Core)
String DUCO_SHA1(String payload) {
  mbedtls_sha1_context ctx;
  unsigned char output[20];
  char hex_output[41];
  
  mbedtls_sha1_init(&ctx);
  mbedtls_sha1_starts(&ctx);
  mbedtls_sha1_update(&ctx, (const unsigned char*)payload.c_str(), payload.length());
  mbedtls_sha1_finish(&ctx, output);
  mbedtls_sha1_free(&ctx);

  for (int i = 0; i < 20; i++) {
    sprintf(hex_output + (i * 2), "%02x", output[i]);
  }
  hex_output[40] = 0;
  return String(hex_output);
}

void loop() {
  // 2. Connect to Pool
  if (!client.connected()) {
    Serial.println("[POOL] Connecting to Duino-Coin server...");
    if (client.connect(POOL_URL, POOL_PORT)) {
      Serial.println("[POOL] Connected successfully.");
      // Wait for server version
      while (client.available() == 0) delay(100);
      String serverVersion = client.readStringUntil('\n');
      Serial.println("[SERVER] Version: " + serverVersion);
    } else {
      Serial.println("[ERROR] Connection failed. Retrying in 5s...");
      delay(5000);
      return;
    }
  }

  // 3. Request Job
  // Format: JOB,user,difficulty,key
  client.print("JOB," + String(DUCO_USER) + ",LOW," + String(RIG_IDENTIFIER) + "\n");
  
  // 4. Read Job
  while (client.available() == 0) {
    if (!client.connected()) return;
    delay(10);
  }
  
  String job = client.readStringUntil('\n');
  job.trim(); // Clean spaces
  
  // Parse job: last_hash, expected_hash, difficulty
  int firstComma = job.indexOf(',');
  int secondComma = job.indexOf(',', firstComma + 1);
  
  if (firstComma > 0 && secondComma > 0) {
    String lastBlockHash = job.substring(0, firstComma);
    String expectedHash = job.substring(firstComma + 1, secondComma);
    int difficulty = job.substring(secondComma + 1).toInt();
    
    // 5. Mine (Brute force to find nonce)
    // Serial.println("[MINING] Working on block... Diff: " + String(difficulty));
    unsigned long startTime = millis();
    digitalWrite(LED_PIN, HIGH); // LED ON while mining
    
    for (int nonce = 0; nonce < difficulty * 100 + 1000; nonce++) {
      String result = DUCO_SHA1(lastBlockHash + String(nonce));
      
      if (result == expectedHash) {
        unsigned long elapsedTime = millis() - startTime;
        float hashrate = nonce / (elapsedTime / 1000.0);
        
        digitalWrite(LED_PIN, LOW); // LED OFF
        
        // 6. Submit Result
        client.print(String(nonce) + "," + String(hashrate) + ",DUCO-ESP32,Ver3.0\n");
        
        // Read feedback (GOOD/BAD)
        while (client.available() == 0) {}
        String feedback = client.readStringUntil('\n');
        Serial.println("[RESULT] " + feedback + " | Hashrate: " + String(hashrate) + " H/s | Nonce: " + String(nonce));
        break;
      }
    }
  }
}

Global Hashrate

Control Deck

Miner Nodes (0)