yggm/sources/main.cpp

#include <sodium.h>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <vector>
#include <array>
#include <string>
#include <memory.h>
#include <thread>
#include <regex>
#include <atomic>
#include <arpa/inet.h>
#include <immintrin.h>
using Key = std::array<unsigned char, 32>;
using Address = std::array<unsigned char, 16>;
struct KeysBox {
    Key PublicKey;
    Key PrivateKey;
};
struct option {
    unsigned int proc = 0;
    bool log = true;
    std::atomic<int> high{ 20 };
    std::string outputfile;
};
static option conf;
int parameters(option& conf, std::string arg) {
    if (arg.find(" ") != std::string::npos) {
        const unsigned long npos = std::string::npos;
        int position = arg.find(" ");
        std::istringstream ss(arg.substr(position + 1));
        if (arg.find("--threads") != npos || arg.find("-t") != npos) {
            ss >> conf.proc;
            if (ss.fail()) return 1;
            return 0;
        }
        if (arg.find("--altitude") != npos || arg.find("-a") != npos) {
            int tmp_high;
            ss >> std::hex >> tmp_high;
            if (ss.fail()) return 1;
            conf.high = tmp_high;
            return 0;
        }
    }
    if (arg == "--threads" || arg == "-t") return 777;
    else if (arg == "--altitude" || arg == "-a") return 777;
    return 0;
}

void displayConfig() {
    unsigned short processor_count = std::thread::hardware_concurrency();
    if (conf.proc == 0 || conf.proc > static_cast<unsigned int>(processor_count)) {
        conf.proc = static_cast<unsigned int>(processor_count);
    }
    std::cout << " Threads: " << conf.proc << ", " << "high addresses (2" << std::setw(2) << std::setfill('0') << std::hex << conf.high << "+)" << std::dec << std::endl;
}
KeysBox getKeyPair() noexcept {
    KeysBox keys;
    crypto_sign_ed25519_keypair(keys.PublicKey.data(), keys.PrivateKey.data());
    return keys;
}
std::string getAddress(const Address& rawAddr) {
    char ipStrBuf[46];
    inet_ntop(AF_INET6, rawAddr.data(), ipStrBuf, 46);
    return std::string(ipStrBuf);
}
inline std::string keyToString(const Key& key) {
    std::string result;
    result.resize(64);
    const char* hexDigits = "0123456789abcdef";
    for (int i = 0; i < 32; ++i) {
        result[2 * i] = hexDigits[key[i] >> 4];
        result[2 * i + 1] = hexDigits[key[i] & 0x0F];
    }
    return result;
}

inline Key bitwiseInverse(const Key& key) noexcept {
    Key inverted;
    for (unsigned long i = 0; i < 32; i++) {
        inverted[i] = ~key[i];
    }
    return inverted;
}
int getOnes(const Key&& value) noexcept {
    int leadOnes = 0;
    for (unsigned char i = 0; i < 17; ++i) {
        if (value[i] == 0xFF) {
            leadOnes += 8;
        } else {
            for (int j = 7; j >= 0; j--) {
                if (value[i] & (1 << j)) {
                    leadOnes++;
                } else {
                    return leadOnes;
                }
            }
        }
    }
    return leadOnes;
}
void miner_thread() {
    while (true) {
        KeysBox keys = getKeyPair();
        int ones = getOnes(bitwiseInverse(keys.PublicKey));
        int current = conf.high.load(std::memory_order_relaxed);
        if (ones > current) {
            while (!conf.high.compare_exchange_weak(current, ones, std::memory_order_relaxed)) {
                if (ones <= current) break;
            }
            if (ones > current) {
                printf("\nAddr:\t2%x\nPK:\t%s\nSK:\t%s\n", ones, keyToString(keys.PublicKey).c_str(), keyToString(keys.PrivateKey).c_str());
            }
        }
    }
}
void startThreads() {
    std::vector<std::thread> threads;
    for (unsigned int i = 0; i < conf.proc; i++) {
        threads.emplace_back(miner_thread);
    }
    for (auto& thread : threads) {
        thread.join();
    }
}
int main(int argc, char* argv[]) {
    if (argc >= 2) {
        int res = -1;
        for (int i = 1;; ++i) {
            if (argv[i] == nullptr) break;
            res = parameters(conf, std::string(argv[i]));
            if (res == 777) {
                i++;
                if (argv[i] == nullptr) {
                    std::cerr << " Empty value for parameter \"" << argv[i - 1] << "\"" << std::endl;
                    return 776;
                }
                int res2 = parameters(conf, std::string(std::string(argv[i - 1]) + " " + std::string(argv[i])));
                if (res2 != 0) {
                    std::cerr << " Wrong value \"" << argv[i] << "\" for parameter \"" << argv[i - 1] << "\"" << std::endl;
                    return res;
                }
            }
        }
    }
    displayConfig();
    startThreads();
}
/*
void getRawAddress(int lErase, Key& InvertedPublicKey, Address& rawAddr) {
    lErase++;
    const int bitsToShift = lErase % 8;
    const int start = lErase / 8;
    const int invSize = start + 15;
    if (bitsToShift == 0) {
        for (int i = start; i < invSize; ++i)
            InvertedPublicKey[i] = InvertedPublicKey[i];
    } else {
        const int complementary = 8 - bitsToShift;
        for (int i = start; i < start + 15; ++i) {
            InvertedPublicKey[i] = static_cast<unsigned char>((InvertedPublicKey[i] << bitsToShift) | (InvertedPublicKey[i + 1] >> complementary));
        }
    }
    rawAddr[0] = 0x02;
    rawAddr[1] = static_cast<unsigned char>(lErase - 1);
    memcpy(&rawAddr[2], &InvertedPublicKey[start], 14);
}
void logKeys(const Address& raw, const KeysBox& keys) {
    std::cout << std::endl;
    std::cout << " Address:    " << getAddress(raw) << std::endl;
    std::cout << " PublicKey:  " << keyToString(keys.PublicKey) << std::endl;
    std::cout << " PrivateKey: " << keyToString(keys.PrivateKey);
    if (!conf.log || conf.fullkeys) std::cout << keyToString(keys.PublicKey);
    std::cout << std::endl << std::endl;
    if (conf.log) {
        std::ofstream output(conf.outputfile, std::ios::app);
        output << std::endl;
        output << "Address:    " << getAddress(raw) << std::endl;
        output << "PublicKey:  " << keyToString(keys.PublicKey) << std::endl;
        output << "PrivateKey: " << keyToString(keys.PrivateKey) << keyToString(keys.PublicKey) << std::endl;
        output.close();
    }
}
*/