From 74bc84172cd396710456ea51f3032f87182dae61 Mon Sep 17 00:00:00 2001
From: w12 <w12@noreply.localhost>
Date: Mon, 23 Dec 2024 10:47:22 +0100
Subject: [PATCH] Dateien nach "/" hochladen

---
 create_genesis.cpp | 152 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 152 insertions(+)
 create mode 100644 create_genesis.cpp

diff --git a/create_genesis.cpp b/create_genesis.cpp
new file mode 100644
index 0000000..915ed3f
--- /dev/null
+++ b/create_genesis.cpp
@@ -0,0 +1,152 @@
+#include <iostream>
+#include <string>
+#include "yespower.h"
+#include <vector>
+#include <array>
+#include <ctime>
+#include <cstring>
+#include <iomanip>
+#include <thread>
+#include <atomic>
+#include <mutex>
+
+yespower_params_t yespower_params = { .version = YESPOWER_1_0, .N = 2048, .r = 16 };
+
+using uint256 = std::array<uint8_t, 32>;
+
+uint256 CalculateMerkleRoot(const std::string &genesisMessage, const std::string &publicKey) {
+    uint256 merkleRoot = {};
+    std::string combined = genesisMessage + publicKey;
+    std::hash<std::string> hasher;
+    size_t hash = hasher(combined);
+    memcpy(merkleRoot.data(), &hash, sizeof(hash));
+    return merkleRoot;
+}
+
+struct CBlockHeader {
+    uint32_t nTime;
+    uint32_t nBits;
+    uint32_t nNonce;
+    uint256 hashMerkleRoot;
+
+    std::string Serialize() const {
+        std::ostringstream ss;
+        ss << nTime << nBits << nNonce;
+        for (const auto &byte : hashMerkleRoot) {
+            ss << std::hex << std::setw(2) << std::setfill('0') << (int)byte;
+        }
+        return ss.str();
+    }
+};
+
+class arith_uint256 {
+    uint64_t value = 0;
+
+public:
+    void SetCompact(uint32_t nBits) {
+        value = nBits;
+    }
+
+    bool operator<=(const arith_uint256 &other) const {
+        return value <= other.value;
+    }
+
+    std::string GetHex() const {
+        std::ostringstream ss;
+        ss << std::hex << value;
+        return ss.str();
+    }
+};
+
+std::atomic<bool> found(false);
+std::mutex printMutex;
+
+void MineThread(CBlockHeader genesisBlock, arith_uint256 hashTarget, int threadID, int numThreads) {
+    uint256 resultHash = {};
+    uint32_t nonce = threadID;
+
+    while (!found) {
+        genesisBlock.nNonce = nonce;
+
+        std::string serializedHeader = genesisBlock.Serialize();
+        yespower_tls(reinterpret_cast<const uint8_t *>(serializedHeader.c_str()),
+                     serializedHeader.size(),
+                     &yespower_params,
+                     reinterpret_cast<yespower_binary_t *>(resultHash.data()));
+
+        arith_uint256 newhash;
+        memcpy(&newhash, resultHash.data(), sizeof(newhash));
+
+        if (newhash <= hashTarget) {
+            found = true;
+            std::lock_guard<std::mutex> lock(printMutex);
+            std::cout << "\nGenesis Block Found by Thread " << threadID << "!\n";
+            std::cout << "Hash: ";
+            for (auto byte : resultHash) {
+                printf("%02x", byte);
+            }
+            std::cout << "\nnTime: " << genesisBlock.nTime << "\n";
+            std::cout << "nNonce: " << genesisBlock.nNonce << "\n";
+            std::cout << "Merkle Root: ";
+            for (auto byte : genesisBlock.hashMerkleRoot) {
+                printf("%02x", byte);
+            }
+            std::cout << "\n";
+            break;
+        }
+
+        nonce += numThreads;
+    }
+}
+
+void MineGenesis() {
+    const uint32_t nBits = 0x1e00ffff;
+    const std::string genesisMessage = "One coin to rule them all One coin to find them One coin to bring them And in the darkness bind them";
+    const std::string publicKey = "043056301006072a8648ce3d020106052b8104000a034200042d23252e243d07ee9a6bcf82200b6f98748a90323b36513ea3f62165d75b12f4269cb91e3c0a01572ab64997e62615e9b25ac97413eccabb2391eebc4c633dd7";
+
+    CBlockHeader genesisBlock;
+    genesisBlock.nTime = std::time(0);
+    genesisBlock.nBits = nBits;
+    genesisBlock.nNonce = 0;
+    genesisBlock.hashMerkleRoot = CalculateMerkleRoot(genesisMessage, publicKey);
+
+    std::cout << "Genesis Block Parameters:\n";
+    std::cout << "nTime: " << genesisBlock.nTime << "\n";
+    std::cout << "nBits: " << std::hex << nBits << "\n";
+    std::cout << "Public Key: " << publicKey << "\n";
+    std::cout << "Genesis Message: " << genesisMessage << "\n";
+
+    arith_uint256 hashTarget;
+    hashTarget.SetCompact(nBits);
+
+    int maxThreads = std::thread::hardware_concurrency();
+    int numThreads = static_cast<int>(maxThreads * 0.8); // Verwende 80% der verfügbaren Threads
+    std::vector<std::thread> threads;
+
+    for (int i = 0; i < numThreads; ++i) {
+        threads.emplace_back(MineThread, genesisBlock, hashTarget, i, numThreads);
+    }
+
+    for (auto &t : threads) {
+        t.join();
+    }
+
+    if (!found) {
+        std::cout << "Genesis Block not found. Adjust parameters and retry.\n";
+    }
+}
+
+int main() {
+    MineGenesis();
+    return 0;
+}
+
+
+
+# create public key with my script
+
+# compile
+# g++ -o genesis create_genesis.cpp -lyespower
+
+# start
+# ./genesis