fix terminal/.../collision.cxx and add some random project XD

Author: Mrezadwiprasetiawan

CMakeLists.txt

@@ -42,5 +42,6 @@ else()
 endif()
 
 add_subdirectory(terminal)
+add_subdirectory(swb)
 
 find_package(OpenMP REQUIRED COMPONENTS CXX)

swb/CMakeLists.txt

@@ -0,0 +1,3 @@
+include_directories(include)
+file(GLOB_RECURSE SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cxx")
+add_executable(swb ${SOURCES})

swb/include/blockchain.hxx

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <array>
+#include <bit>
+#include <cstdint>
+#include <string>
+
+#include "sha3-512.hxx"
+#include "uint512_t.hxx"
+
+struct Header {
+ private:
+  static constexpr std::array<char, 4> magicBE_raw = {0x0d, 0x0a, 0x12, 0x0e};
+
+ public:
+  static constexpr std::array<char, 4> magic = []() constexpr {
+    if constexpr (std::endian::native == std::endian::little) return std::array<char, 4>{magicBE_raw[3], magicBE_raw[2], magicBE_raw[1], magicBE_raw[0]};
+    else return magicBE_raw;
+  }();
+
+  static inline const std::string version_STR = "000001";
+  static inline const uint64_t version = 1;
+};
+
+class Block {
+  Block *prev = nullptr;
+  uint512_t hash{};
+  std::string hashHex{};
+  uint512_t nonce{};
+  bool verified = false;
+
+ public:
+  explicit Block() = default;
+
+  void generate_hash(const Block *prevBlock, const uint512_t &nonceVal) {
+    using namespace std;
+    string input;
+    if (prevBlock) input += prevBlock->hashHex;
+    input.append(Header::magic.begin(), Header::magic.end());
+    input += Header::version_STR;
+    input += to_string(Header::version);
+    input += static_cast<std::string>(nonceVal);
+    hash = SHA3_512::hash(input);
+    hashHex = hash.to_hex();
+  }
+
+  static bool check(double difficulty, Block chBlock) {
+    uint512_t test = chBlock.hash;
+    chBlock.generate_hash(chBlock.prev, chBlock.nonce);
+    if (chBlock.hash == test) {
+      chBlock.verified = true;
+      return true;
+    }
+    chBlock.hash = test;
+    return false;
+  }
+};

swb/include/endian.hxx

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <cstdint>
+
+inline static bool is_big_endian() {
+  uint16_t data = 0xff00;
+  return *reinterpret_cast<uint8_t*>(&data);
+}

swb/include/miner.hxx

@@ -0,0 +1,131 @@
+#pragma once
+#include <array>
+#include <chrono>
+#include <cstdint>
+#include <iostream>
+#include <mutex>
+#include <sstream>
+#include <thread>
+#include <vector>
+
+#include "sha3-512.hxx"
+#include "uint512_t.hxx"
+
+struct Target512 {
+  uint512_t value{};
+
+  static Target512 initial() {
+    Target512 t;
+    t.value[0] = 0x00;
+    t.value[1] = 0x00;
+    t.value[2] = 0x00;
+    t.value[3] = 0xFF;
+    return t;
+  }
+
+  bool check(const uint512_t& i) const { return i <= value; }
+
+  void update_difficulty(double factor) {
+    using namespace std;
+
+    constexpr uint64_t SCALE = 10000;
+    uint512_t scale(SCALE);
+
+    if (factor < 1.0) {
+      double inv = 1.0 / factor;
+      uint64_t scaled = static_cast<uint64_t>(inv * SCALE);
+      value /= scale;
+      value *= uint512_t(scaled);
+    } else {
+      uint64_t scaled = static_cast<uint64_t>(factor * SCALE);
+      value /= uint512_t(scaled);
+      value *= scale;
+    }
+  }
+};
+
+struct Miner512 {
+  Target512 target;
+  std::mutex print_mtx;
+  std::mutex nonce_mtx;
+  uint512_t winning_nonce{};
+  int num_threads = 4;
+  uint64_t sumTime = 0;
+
+  Miner512() : target(Target512::initial()), winning_nonce(0) {}
+
+  void mine_thread(const std::string& weight, int thread_id, bool& block_found, std::array<std::string, 64>& thread_hashes) {
+    using namespace std;
+    uint512_t local_nonce = uint512_t(static_cast<uint64_t>(thread_id));
+    while (true) {
+      {
+        lock_guard<mutex> lg(nonce_mtx);
+        if (block_found) break;
+      }
+
+      stringstream ss;
+      ss << local_nonce.to_hex() << weight;
+      uint512_t hash = SHA3_512::hash(ss.str());
+      thread_hashes[thread_id] = hash.to_hex();
+
+      if (target.check(hash)) {
+        lock_guard<mutex> lg(nonce_mtx);
+        if (winning_nonce == uint512_t(0) || local_nonce < winning_nonce) winning_nonce = local_nonce;
+        block_found = true;
+        break;
+      }
+
+      local_nonce += uint512_t(num_threads);
+    }
+  }
+
+  void mine_concurrent(int threads = 4) {
+    using namespace std;
+    num_threads = threads;
+    uint64_t total_found = 0;
+    string prev_hash = "";
+
+    while (true) {
+      bool block_found = false;
+      winning_nonce = uint512_t(0);
+      array<string, 64> thread_hashes;
+      vector<thread> thread_pool;
+
+      {
+        lock_guard<mutex> lg(print_mtx);
+        cout << "Current target is " << target.value.to_hex() << endl << endl;
+      }
+      auto start = chrono::high_resolution_clock::now();
+
+      for (int i = 0; i < num_threads; ++i) thread_pool.emplace_back(&Miner512::mine_thread, this, ref(prev_hash), i, ref(block_found), ref(thread_hashes));
+
+      for (auto& t : thread_pool) t.join();
+
+      auto end = chrono::high_resolution_clock::now();
+      auto duration = chrono::duration_cast<chrono::milliseconds>(end - start).count();
+      if (duration == 0) duration = 1;
+      sumTime += duration;
+      {
+        lock_guard<mutex> lg(print_mtx);
+        cout << "Block found! Winning nonce = " << winning_nonce.to_hex() << " Time = " << duration << "ms Total blocks found = " << (++total_found) << endl;
+        cout << "Hashes from threads:" << endl;
+        for (int i = 0; i < num_threads; ++i) cout << "[Thread " << i << "] hash=" << thread_hashes[i] << endl;
+        cout << endl;
+      }
+
+      prev_hash = thread_hashes[0];
+      for (int i = 1; i < num_threads; ++i)
+        if (!thread_hashes[i].empty() && (winning_nonce % uint512_t(num_threads) == uint512_t(i))) prev_hash = thread_hashes[i];
+
+      if (!(total_found % 10)) {
+        double factor = 60000.0 / static_cast<double>(sumTime) * 10;  // target 60s per block }
+        target.update_difficulty(factor);
+        sumTime = 0;
+        {
+          lock_guard<mutex> lg(print_mtx);
+          cout << "Difficulty updated with factor = " << factor << endl << endl;
+        }
+      }
+    }
+  }
+};

swb/include/peer.hxx

@@ -0,0 +1,14 @@
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <cstdint>
+#include <vector>
+
+#include "uint512_t.hxx"
+
+/*
+ */
+struct NetPool {
+  std::vector<uint512_t> Id;
+  std::vector<int> MostNewOffset;
+};

swb/include/sha3-512.hxx

@@ -0,0 +1,132 @@
+#pragma once
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "uint512_t.hxx"
+
+class SHA3_512 {
+ private:
+  static constexpr size_t KECCAKF_ROUNDS = 24;
+  static constexpr uint64_t keccakf_rndc[24] = {
+      0x0000000000000001ULL, 0x0000000000008082ULL, 0x800000000000808aULL, 0x8000000080008000ULL, 0x000000000000808bULL, 0x0000000080000001ULL,
+      0x8000000080008081ULL, 0x8000000000008009ULL, 0x000000000000008aULL, 0x0000000000000088ULL, 0x0000000080008009ULL, 0x000000008000000aULL,
+      0x000000008000808bULL, 0x800000000000008bULL, 0x8000000000008089ULL, 0x8000000000008003ULL, 0x8000000000008002ULL, 0x8000000000000080ULL,
+      0x000000000000800aULL, 0x800000008000000aULL, 0x8000000080008081ULL, 0x8000000000008080ULL, 0x0000000000008001ULL, 0x8000000080008008ULL};
+
+  static constexpr uint8_t keccakf_rotc[24] = {1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 2, 14, 27, 41, 56, 8, 25, 43, 62, 18, 39, 61, 20, 44};
+
+  static constexpr uint8_t keccakf_piln[24] = {10, 7, 11, 17, 18, 3, 5, 16, 8, 21, 24, 4, 15, 23, 19, 13, 12, 2, 20, 14, 22, 9, 6, 1};
+
+  static inline uint64_t rol64(uint64_t x, unsigned s) { return (x << s) | (x >> (64 - s)); }
+
+  static void keccakf(uint64_t* st) {
+    uint64_t t, bc[5];
+    for (size_t round = 0; round < KECCAKF_ROUNDS; ++round) {
+      for (int i = 0; i < 5; ++i) bc[i] = st[i] ^ st[i + 5] ^ st[i + 10] ^ st[i + 15] ^ st[i + 20];
+      for (int i = 0; i < 5; ++i) {
+        t = bc[(i + 4) % 5] ^ rol64(bc[(i + 1) % 5], 1);
+        for (int j = 0; j < 25; j += 5) st[j + i] ^= t;
+      }
+      t = st[1];
+      for (int i = 0; i < 24; ++i) {
+        int j = keccakf_piln[i];
+        bc[0] = st[j];
+        st[j] = rol64(t, keccakf_rotc[i]);
+        t = bc[0];
+      }
+      for (int j = 0; j < 25; j += 5) {
+        for (int i = 0; i < 5; ++i) bc[i] = st[j + i];
+        st[j + 0] = bc[0] ^ ((~bc[1]) & bc[2]);
+        st[j + 1] = bc[1] ^ ((~bc[2]) & bc[3]);
+        st[j + 2] = bc[2] ^ ((~bc[3]) & bc[4]);
+        st[j + 3] = bc[3] ^ ((~bc[4]) & bc[0]);
+        st[j + 4] = bc[4] ^ ((~bc[0]) & bc[1]);
+      }
+      st[0] ^= keccakf_rndc[round];
+    }
+  }
+
+  static inline bool is_little_endian() {
+    uint16_t x = 1;
+    return *reinterpret_cast<uint8_t*>(&x) == 1;
+  }
+
+  static inline uint64_t swap64(uint64_t x) {
+    return ((x & 0x00000000000000FFULL) << 56) | ((x & 0x000000000000FF00ULL) << 40) | ((x & 0x0000000000FF0000ULL) << 24) |
+           ((x & 0x00000000FF000000ULL) << 8) | ((x & 0x000000FF00000000ULL) >> 8) | ((x & 0x0000FF0000000000ULL) >> 24) | ((x & 0x00FF000000000000ULL) >> 40) |
+           ((x & 0xFF00000000000000ULL) >> 56);
+  }
+
+  static void update(const uint8_t* data, size_t len, uint64_t (&st)[25], std::vector<uint8_t>& buf) {
+    while (len--) {
+      buf.push_back(*data++);
+      if (buf.size() == 72) {
+        for (size_t i = 0; i < 9; ++i) {
+          uint64_t t = 0;
+          for (size_t j = 0; j < 8; ++j) t |= ((uint64_t)buf[i * 8 + j]) << (8 * j);
+          st[i] ^= t;
+        }
+        keccakf(st);
+        buf.clear();
+      }
+    }
+  }
+
+  static void finalize(uint64_t (&st)[25], std::vector<uint8_t>& buf) {
+    buf.push_back(0x06);
+    while (buf.size() < 72) buf.push_back(0x00);
+    buf[71] |= 0x80;
+    for (size_t i = 0; i < 9; ++i) {
+      uint64_t t = 0;
+      for (size_t j = 0; j < 8; ++j) t |= ((uint64_t)buf[i * 8 + j]) << (8 * j);
+      st[i] ^= t;
+    }
+    keccakf(st);
+  }
+
+ public:
+  static uint512_t hash(const std::string& s) {
+    using namespace std;
+    uint64_t st[25]{};
+    vector<uint8_t> buf;
+    update(reinterpret_cast<const uint8_t*>(s.data()), s.size(), st, buf);
+    finalize(st, buf);
+
+    array<uint8_t, 64> out{};
+    bool little = is_little_endian();
+    for (size_t i = 0; i < 8; ++i) {
+      uint64_t lane = st[i];
+      if (little) lane = swap64(lane);
+      for (int j = 0; j < 8; ++j) out[i * 8 + j] = (lane >> (8 * (7 - j))) & 0xFF;
+    }
+    uint512_t val;
+    for (int i = 0; i < 64; ++i) val.dataBE[i] = out[i];
+    return val;
+  }
+
+  static std::string hash_hex(const std::string& s) {
+    using namespace std;
+    uint64_t st[25]{};
+    vector<uint8_t> buf;
+    update(reinterpret_cast<const uint8_t*>(s.data()), s.size(), st, buf);
+    finalize(st, buf);
+
+    ostringstream oss;
+    bool little = is_little_endian();
+    for (size_t i = 0; i < 8; ++i) {
+      uint64_t lane = st[i];
+      if (little) lane = swap64(lane);
+      for (int j = 0; j < 8; ++j) {
+        uint8_t b = (lane >> (8 * (7 - j))) & 0xFF;
+        oss << hex << setw(2) << setfill('0') << (int)b;
+      }
+    }
+    return oss.str();
+  }
+};