Bitcoin Halving & Miner Kapitulation - Simulation! + Quellcode

In diesem Beitrag geht es um die Programmierung einer Simulation im Falle einer Miner Kapitulation nach dem Halving Event. Bei dieser in Java programmierten Simulation geht es um die Frage nach der Lebensdauer des Bitcoin Netzwerks im Falle einer Miner Kapitulation. In diesem Szenario passt sich die Schwierigkeit des Bitcoin Netzwerk zu langsam an und immer mehr Miner steigen aus.

Ich halte dieses Szenario persönlich für sehr unwahrscheinlich, dennoch birgt die Technologie dieses Gefahr. Dieses Simulation soll nun auch keine Unsicherheit streuen, vielmehr geht es um das grundlegende Verständnis dieses dezentralen Systems.

Hierzu habe ich auch ein ausführliches Video gemacht, dieses könnt ihr euch auf YouTube anschauen:

Auf Wunsch aus der Community veröffentliche ich hier natürlich auch den Quellcode des Projekts:

/*
 * Crypto Mining Simulation zur Demonstration der Halfing Problematik
*/

package com.mycompany.sozial;

import static java.lang.Thread.sleep;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Scanner;

/**
 * @author Alexander Weipprecht
 */
public class Main {
    
    public static void main(String[] args) throws NoSuchAlgorithmException, InterruptedException{     
       /*  
           Festlegen der Schwierigkeit (Vereinfachtes Beispiel für dieses Programm)
           11 Mai Bitcoin Halfing
           Difficulty Adjustment: 31 Mai
           ca. 20 Tage
       */
       float Schwierigkeit          = 1;       // Variable anlegen
       int AnzahlMiner              = 200000;  // Anzahl der Miner bei Start 
       float TimeforBlock           = 10;      // Zielwert für Blocktime
       float CurTimeforblock        = 0;       // Varibale für aktuelle Blocktime
       int BlockToDifCorrection     = 0;       // Laufvariable bis zum nächsten Update der Schwierigkeit 
       float TimeToDifCorrectuion   = 0;       // Variable zur Berechnung der Zeit bis zum Update
       float AvgDifficultyTime      = 0;       // Durchnittliche Zeit bis Block gefunden wird der letztn 2016 Blöcke
       float AvgSumme               = 0;       // Zwischenvariable für Summe
       float FaktorKapitulation     = 0;       // Hilfsvariable zur Berechnung der Minerkapitulation
       
       // Steuerungsvariablen Simulation
       int BlocktimeTolleranz       = 30;       // So lange sind Miner bereit auf einen Block zu warten ohne das sie abschalten
       float Einbruch               = 0.5f;     // 0.5 = 50% Einbruch, 0.4 = 60% Einbruch zum Zeitpunkt des Halfings
       
       // Initiale Schwierigkeit wird berechnet
       Schwierigkeit = FindNewDifficulty(Schwierigkeit,AnzahlMiner,TimeforBlock,CurTimeforblock);
       
       // Blöcke erzeugen
       for(int Block = 1; Block < 5000; Block++){
          // Erzeuge Block
          CurTimeforblock = FindBlock(Schwierigkeit,AnzahlMiner);
          // Zählervariable bis Block 2016 wird +1 erhöht 
          BlockToDifCorrection++;
          // Durchnittliche Blockzeit berechnen
          AvgDifficultyTime = (AvgSumme + CurTimeforblock) / BlockToDifCorrection;
          // Summe bilden für durschnittliche Blockzeit Berechnung
          AvgSumme += CurTimeforblock;
                    
          // Bei Block 2016 prüfen
          if(BlockToDifCorrection == 2016){
               // Wenn Blockzeit länger oder kürzer als 10 Minuten braucht
               if(AvgDifficultyTime > TimeforBlock || AvgDifficultyTime < TimeforBlock){
                  // Neue Schwierigkeit berechnen, Zielwert sind 10 Minuten
                  Schwierigkeit = FindNewDifficulty(Schwierigkeit,AnzahlMiner,TimeforBlock,CurTimeforblock);
                  System.out.println(" UPDATE SCHWIERIGKEIT ");
               }
               // Reset Laufvariable
               BlockToDifCorrection = 0;
               // Reset Summe
               AvgSumme = 0;
          }
          // Zeit bis zur nächsten Anpassung in Tagen
          TimeToDifCorrectuion = (((2016 - BlockToDifCorrection) * CurTimeforblock) / 60) / 24;
          
          // Ausgabe
          System.out.println("Block: " + Block + " | Zeit: " + Math.round(CurTimeforblock) + " Minuten | Miner: " + AnzahlMiner + " | Schwierigkeit: " + Math.round(Schwierigkeit) + " | Avg Time:" + AvgDifficultyTime + " Minuten | Next Diff: " + (2016 - BlockToDifCorrection) + " Blöcke | Time Diff: " + TimeToDifCorrectuion + " Tage");
          
          
          // Einbruch der Miner durch Halfing Event ca. 10 Tage vor Anpassung
          if(Block == 576){
             // Miner reduzieren, entsprechend Einbruchvariable
             AnzahlMiner *= Einbruch;
             // Ausgabe in der Konsole
             System.out.println(" MINER DROP ");
          }
          // Ab Einbruch findet eine Kapitulation Schrittweise statt ca. 2 Tage vor Difficulty Adjustment
          if(Block > 576){
             // Faktor des weiteren Einbruchs berechnen
             FaktorKapitulation = (1 - (CurTimeforblock * 0.001f));
             
             // Einbruch setzt sich nur fort, wenn die Tolletanz nicht überschritten wird
             if(CurTimeforblock > BlocktimeTolleranz){
                AnzahlMiner *= FaktorKapitulation;
             } 
          }
          
          // Wenn kein Miner mehr im Netzwerk ist
          if(AnzahlMiner <= 0){
              System.out.println(" EXIT - ALLE MINER SCHALTEN AB ");
              break;
          }
       }
    }
    
    // Finde neue Schwierigkeit
    public static float FindNewDifficulty(float Schwierigkeit,int AnzahlMiner,float TimeforBlock,float CurTimeforblock){
       if(CurTimeforblock > TimeforBlock){
           while(FindBlock(Schwierigkeit,AnzahlMiner) >= TimeforBlock){
              // Reduziere Schwierigkeit so lange, bis Blockzeit >= 10 Minunten
              Schwierigkeit -= 0.1f; 
              if(Schwierigkeit <= 1){
                 return Schwierigkeit;
              }
           }
       }else{
           while(FindBlock(Schwierigkeit,AnzahlMiner) <= TimeforBlock){
              // Eröhe Schwierigkeit so lange, bis Blockzeit <= 10 Minuten 
              Schwierigkeit += 0.1f;  
           }
       }
       return Schwierigkeit;
    }
    
    // Erzeuge einen Block für die Blockchain
    public static float FindBlock(float Schwierigkeit,int AnzahlMiner){
        // Schwierigkeit / Anzahl der Miner * 1000 sollte 10 ergeben
        return ((Schwierigkeit / AnzahlMiner) * 1000);
    }
    

}

Häufig gestellte Fragen: Bitcoin Halving & Miner Kapitulation - Simulation!