Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 182. (Read 244669 times)

import sys
import os
import time
import gmpy2
from gmpy2 import mpz
from functools import lru_cache
import secp256k1 as ice
import multiprocessing
from multiprocessing import Pool, cpu_count

# Constants
MODULO = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
ORDER = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141)
GX = gmpy2.mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
GY = gmpy2.mpz(0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)

# Define Point class
class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

PG = Point(GX, GY)
ZERO_POINT = Point(0, 0)

# Function to multiply a point by 2
@lru_cache(maxsize=None)
def multiply_by_2(P, p=MODULO):
    c = gmpy2.f_mod(3 * P.x * P.x * gmpy2.powmod(2 * P.y, -1, p), p)
    R = Point()
    R.x = gmpy2.f_mod(c * c - 2 * P.x, p)
    R.y = gmpy2.f_mod(c * (P.x - R.x) - P.y, p)
    return R

# Function to add two points
@lru_cache(maxsize=None)
def add_points(P, Q, p=MODULO):
    dx = Q.x - P.x
    dy = Q.y - P.y
    c = gmpy2.f_mod(dy * gmpy2.invert(dx, p), p)
    R = Point()
    R.x = gmpy2.f_mod(c * c - P.x - Q.x, p)
    R.y = gmpy2.f_mod(c * (P.x - R.x) - P.y, p)
    return R

# Function to calculate Y-coordinate from X-coordinate
@lru_cache(maxsize=None)
def x_to_y(X, y_parity, p=MODULO):
    Y = gmpy2.mpz(3)
    tmp = gmpy2.mpz(1)

    while Y > 0:
        if Y % 2 == 1:
            tmp = gmpy2.f_mod(tmp * X, p)
        Y >>= 1
        X = gmpy2.f_mod(X * X, p)

    X = gmpy2.f_mod(tmp + 7, p)

    Y = gmpy2.f_div(gmpy2.add(p, 1), 4)
    tmp = gmpy2.mpz(1)

    while Y > 0:
        if Y % 2 == 1:
            tmp = gmpy2.f_mod(tmp * X, p)
        Y >>= 1
        X = gmpy2.f_mod(X * X, p)

    Y = tmp

    if Y % 2 != y_parity:
        Y = gmpy2.f_mod(-Y, p)

    return Y

# Function to compute a table of points
def compute_point_table():
    points = [PG]
    for k in range(255):
        points.append(multiply_by_2(points[k]))
    return points

POINTS_TABLE = compute_point_table()

# Global event to signal all processes to stop
STOP_EVENT = multiprocessing.Event()

# Function to check and compare points for potential solutions
def check(P, Pindex, DP_rarity, A, Ak, B, Bk):
    check_modulo = gmpy2.f_mod(P.x, DP_rarity)
   
    if check_modulo != 0:
        return False

    message = f"\r[+] [Pindex]: {mpz(Pindex)}"
    messages = []
    messages.append(message)
    output = "\033[01;33m" + ''.join(messages) + "\r"
    sys.stdout.write(output)
    sys.stdout.flush()

    A.append(mpz(P.x))
    Ak.append(mpz(Pindex))

    collision_index_A = find_collision(Ak)
    if collision_index_A is not None:
        return comparator(A, Ak, B, Bk, collision_index_A)

    collision_index_B = find_collision(Bk)
    if collision_index_B is not None:
        return comparator(A, Ak, B, Bk, collision_index_B)

    return False

# Cycle detection function for Ak
def find_collision(Ak):
    seen = set()
    for i, item in enumerate(Ak):
        if item in seen:
            return mpz(i)  # Collision detected, return as mpz
        seen.add(item)
    return None  # No collision detected

# Cycle detection function for Bk
def find_collision(Bk):
    seen = set()
    for i, item in enumerate(Bk):
        if item in seen:
            return mpz(i)  # Collision detected, return as mpz
        seen.add(item)
    return None  # No collision detected

# Function to compare two sets of points and find a common point
def comparator(A, Ak, B, Bk, collision_index):
    global STOP_EVENT
    result = set(A).intersection(set(B))
    if result:
        sol_kt = A.index(next(iter(result)))
        sol_kw = B.index(next(iter(result)))
        difference = Ak[sol_kt] - Bk[sol_kw]
        HEX = "%064x" % difference
        wifc = ice.btc_pvk_to_wif("%064x" % mpz(difference))
        dec = int(ice.btc_wif_to_pvk_hex(wifc), 16)
        wifu = ice.btc_pvk_to_wif(HEX, False)  # Uncompressed
        uaddr = ice.privatekey_to_address(0, False, dec)  # Uncompressed
        caddr = ice.privatekey_to_address(0, True, dec)  # Compressed
        HASH160 = ice.privatekey_to_h160(0, True, dec).hex()
        t = time.ctime()
        total_time = time.time() - starttime
        print(f"\033[32m[+] PUZZLE SOLVED: {t}, total time: {total_time:.2f} sec \033[0m")
        print(f"\033[32m[+] WIF: \033[32m {wifc} \033[0m")
        with open("KEYFOUNDKEYFOUND.txt", "a") as file:
            file.write("\n\nPUZZLE SOLVED " + t)
            file.write(f"\nTotal Time: {total_time:.2f} sec")
            file.write('\nPrivate Key (dec): ' + str(dec))
            file.write('\nPrivate Key (hex): ' + HEX)
            file.write('\nPrivate Key Compressed: ' + wifc)
            file.write('\nPrivate Key Uncompressed: ' + wifu)
            file.write('\nPublic Address Compressed: ' + caddr)
            file.write('\nPublic Address Uncompressed: ' + uaddr)
            file.write('\nPublic Key Hash Compressed (Hash 160): ' + HASH160)
            file.write(
                "\n-------------------------------------------------------------------------------------------------------------------------------------\n"
            )

        STOP_EVENT.set()  # Set the stop event to signal all processes

# Memoization for point multiplication
ECMULTIPLY_MEMO = {}

# Function to multiply a point by a scalar
def ecmultiply(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        if k in ECMULTIPLY_MEMO:
            return ECMULTIPLY_MEMO[k]
        else:
            result = ecmultiply(k // 2, multiply_by_2(P, p), p)
            ECMULTIPLY_MEMO[k] = result
            return result
    else:
        return add_points(P, ecmultiply((k - 1) // 2, multiply_by_2(P, p), p))

# Recursive function to multiply a point by a scalar
def mulk(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        return mulk(k // 2, multiply_by_2(P, p), p)
    else:
        return add_points(P, mulk((k - 1) // 2, multiply_by_2(P, p), p))

# Generate a list of powers of two for faster access
@lru_cache(maxsize=None)
def generate_powers_of_two(hop_modulo):
    return [mpz(1 << pw) for pw in range(hop_modulo)]

# Worker function for point search
def search_worker(Nt, Nw, puzzle, tortoise_power, starttime, lower_range_limit, upper_range_limit):
    global STOP_EVENT

    random_state_t = gmpy2.random_state(hash(gmpy2.random_state()))
    random_state_w = gmpy2.random_state(hash(gmpy2.random_state()))

    t = [mpz(lower_range_limit + gmpy2.mpz_random(random_state_t, upper_range_limit - lower_range_limit)) for _ in range(Nt)]
    T = [mulk(ti) for ti in t]
    dt = [mpz(0) for _ in range(Nt)]
   
    w = [gmpy2.mpz_random(random_state_w, upper_range_limit - lower_range_limit) for _ in range(Nt)]
    W = [add_points(W0, mulk(wk)) for wk in w]
    dw = [mpz(0) for _ in range(Nw)]

    Hops, Hops_old = 0, 0

    oldtime = time.time()
    starttime = oldtime

    while True:
        for k in range(Nt):
            Hops += 1
            pw = T[k].x % hop_modulo
            dt[k] = powers_of_two[pw]
            solved = check(T[k], t[k], DP_rarity, T, t, W, w)
            if solved:
                STOP_EVENT.set()
                raise SystemExit
            t[k] += dt[k]
            T[k] = add_points(POINTS_TABLE[pw], T[k])

        for k in range(Nw):
            Hops += 1
            pw = W[k].x % hop_modulo
            dw[k] = powers_of_two[pw]
            solved = check(W[k], w[k], DP_rarity, W, w, T, t)
            if solved:
                STOP_EVENT.set()
                raise SystemExit
            w[k] += dw[k]
            W[k] = add_points(POINTS_TABLE[pw], W[k])

        if STOP_EVENT.is_set():
            break


# Main script
if __name__ == "__main__":
    os.system("clear")
    t = time.ctime()
    sys.stdout.write("\033[01;33m")
    sys.stdout.write(f"[+] {t}" + "\n")
    sys.stdout.write(f"[+] Cycle detected, applying Floyd's cycle-finding algorithm..." + "\n")
    sys.stdout.flush()
    # Configuration for the puzzle
    puzzle = 50
    compressed_public_key = "03f46f41027bbf44fafd6b059091b900dad41e6845b2241dc3254c7cdd3c5a16c6"  # Puzzle 50
    lower_range_limit = 2 ** (puzzle - 1)
    upper_range_limit = (2 ** puzzle) - 1
    tortoise_power = puzzle // 8
    Nt = Nw = (2 ** tortoise_power // puzzle) * puzzle + 8
    DP_rarity = 8 * puzzle
    hop_modulo = (puzzle // 2) + 8

    # Precompute powers of two for faster access
    powers_of_two = generate_powers_of_two(hop_modulo)

    T, t, dt = [], [], []
    W, w, dw = [], [], []

    if len(compressed_public_key) == 66:
        X = mpz(compressed_public_key[2:66], 16)
        Y = x_to_y(X, mpz(compressed_public_key[:2]) - 2)
    else:
        print("[error] pubkey len(66/130) invalid!")

    print(f"[+] [Puzzle]: {puzzle}")
    print(f"[+] [Lower range limit]: {lower_range_limit}")
    print(f"[+] [Upper range limit]: {upper_range_limit}")
    print("[+] [Xcoordinate]: %064x" % X)
    print("[+] [Ycoordinate]: %064x" % Y)

    W0 = Point(X, Y)
    starttime = oldtime = time.time()

    Hops = 0

    process_count = cpu_count()
    print(f"[+] Using {process_count} CPU cores for parallel search")

    # Create a pool of worker processes
    pool = Pool(process_count)
    results = pool.starmap(
        search_worker,
        [
            (
                Nt,
                Nw,
                puzzle,
                tortoise_power,
                starttime,
                lower_range_limit,
                upper_range_limit,
            )
        ]
        * process_count,
    )
    pool.close()
    pool.join()

import SECP256k1
import Point
import sha256
import Int
import ripemd160
import boost.multiprecision.cpp_int as cpp_int
import gmpy2 as mpz
import math
import time
import threading
import os

START_VALUE = 576565752303423488
END_VALUE = 900000000000000000
INCREMENT = 1

# Define a range of factors
MIN_FACTOR = 64.0
MAX_FACTOR = 1028.0
FACTOR_INCREMENT = 1.00

currentValue = mpz.mpz(START_VALUE)
totalKeys = 0
printMutex = threading.Lock()
resultMutex = threading.Lock()
ripemd160Hashes = []

startTime = None
matchFound = False
currentHexPrivateKey = ""

def loadRIPEMD160Hashes():
    with open("wallets.txt", "r") as file:
        for line in file:
            hexHash = line.strip()
            if len(hexHash) != 40:
                print(f"Invalid RIPEMD160 hash length: {len(hexHash)}")
                continue

            hash = bytearray.fromhex(hexHash)
            ripemd160Hashes.append(hash)

        print(f"Loaded {len(ripemd160Hashes)} RIPEMD160 hashes from file.")

def hexBytesToHexString(bytes):
    return "".join([format(b, "02x") for b in bytes])

def hasMinimumMatchingCharacters(hash):
    for loadedHash in ripemd160Hashes:
        isMatch = True
        for j in range(19): # Loop through the first 5 bytes (40 bits)
            if hash[j] != loadedHash[j]:
                isMatch = False
                break # If any character doesn't match, stop checking
       
        if isMatch:
            return True
   
    return False

def printProgress():
    global startTime
    startTime = time.time()

    while not matchFound:
        elapsed = time.time() - startTime
        keysPerSecond = totalKeys / elapsed if elapsed != 0 else 0

        with resultMutex:
            print(f"\rTime: {int(elapsed)}s, Keys: {totalKeys}, Keys/s: {round(keysPerSecond, 5)}, Current: {currentValue}, Priv Key: {currentHexPrivateKey}", end="")
        time.sleep(5)


def counterWorker(threadId, secp256k1, numThreads):
    global currentHexPrivateKey, matchFound, startTime, totalKeys, currentValue
    current = mpz.mpz(START_VALUE + threadId * INCREMENT)

    while current <= END_VALUE:
        for factor in range(int(MIN_FACTOR), int(MAX_FACTOR) + 1, int(FACTOR_INCREMENT)):
            result = current * int(factor)
            hexPrivateKey = format(int(result), "x") # Get hex representation directly
            currentHexPrivateKey = hexPrivateKey

            privateKey = Int.Int(0)
            privateKey.SetBase16(hexPrivateKey)

            publicKey = secp256k1.ComputePublicKey(privateKey)

            compressedPublicKey = bytearray(secp256k1.GetPublicKeyRaw(True, publicKey))
            publicKeyHash = sha256.sha256(compressedPublicKey)

            ripemd160Hash = ripemd160.ripemd160(publicKeyHash)

            if hasMinimumMatchingCharacters(ripemd160Hash):
                matchedPrivateKey = hexPrivateKey # Store the private key for printing
                matchedRipemd160 = hexBytesToHexString(ripemd160Hash) # Convert RIPEMD160 to hex string

                with printMutex:
                    print(f"\nMatching RIPEMD160 hash found. Private Key: {matchedPrivateKey}, RIPEMD160: {matchedRipemd160}")

                with open("found.txt", "a") as foundFile:
                    foundFile.write(f"Matched Private Key: {matchedPrivateKey}, RIPEMD160: {matchedRipemd160}\n")

                matchFound = True
                break
       
        totalKeys += 1

        # Update the currentValue atomically
        with resultMutex:
            currentValue = current

        current = current + (INCREMENT * numThreads)

    # Signal that this thread has completed its work
    with resultMutex:
        matchFound = True

def main():
    global matchFound, totalKeys, currentValue

    loadRIPEMD160Hashes()

    secp256k1 = SECP256k1.SECP256k1()
    secp256k1.Init()

    threads = []
    numThreads = os.cpu_count()

    # Start the progress printing thread
    progressThread = threading.Thread(target=printProgress)
    progressThread.start()

    for i in range(numThreads):
        threads.append(threading.Thread(target=counterWorker, args=(i, secp256k1, numThreads)))
   
    for thread in threads:
        thread.start()

    for thread in threads:
        thread.join()

    # Wait for the progress thread to complete
    progressThread.join()

    print()

if __name__ == "__main__":
    main()

# Define the EllipticCurve class
class EllipticCurve:
    def __init__(self, a, b, p):
        self.a = a
        self.b = b
        self.p = p

    def contains(self, point):
        x, y = point.x, point.y
        return (y * y) % self.p == (x * x * x + self.a * x + self.b) % self.p

    def __str__(self):
        return f"y^2 = x^3 + {self.a}x + {self.b} mod {self.p}"

# Define the Point class
class Point:
    def __init__(self, x, y, curve):
        self.x = x
        self.y = y
        self.curve = curve

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y and self.curve == other.curve

    def __ne__(self, other):
        return not self == other

    def __add__(self, other):
        if self.curve != other.curve:
            raise ValueError("Cannot add points on different curves")

        # Case when one point is zero
        if self == Point.infinity(self.curve):
            return other
        if other == Point.infinity(self.curve):
            return self

        if self.x == other.x and self.y != other.y:
            return Point.infinity(self.curve)

        p = self.curve.p
        s = 0
        if self == other:
            s = ((3 * self.x * self.x + self.curve.a) * pow(2 * self.y, -1, p)) % p
        else:
            s = ((other.y - self.y) * pow(other.x - self.x, -1, p)) % p

        x = (s * s - self.x - other.x) % p
        y = (s * (self.x - x) - self.y) % p

        return Point(x, y, self.curve)

    def __sub__(self, other):
        if self.curve != other.curve:
            raise ValueError("Cannot subtract points on different curves")

        # Case when one point is zero
        if self == Point.infinity(self.curve):
            return other
        if other == Point.infinity(self.curve):
            return self

        return self + Point(other.x, (-other.y) % self.curve.p, self.curve)

    def __mul__(self, n):
        if not isinstance(n, int):
            raise ValueError("Multiplication is defined for integers only")

        n = n % (self.curve.p - 1)
        res = Point.infinity(self.curve)
        addend = self

        while n:
            if n & 1:
                res += addend

            addend += addend
            n >>= 1

        return res

    def __str__(self):
        return f"({self.x}, {self.y}) on {self.curve}"

    @staticmethod
    def from_hex(s, curve):
        if len(s) == 66 and s.startswith("02") or s.startswith("03"):
            compressed = True
        elif len(s) == 130 and s.startswith("04"):
            compressed = False
        else:
            raise ValueError("Hex string is not a valid compressed or uncompressed point")

        if compressed:
            is_odd = s.startswith("03")
            x = int(s[2:], 16)

            # Calculate y-coordinate from x and parity bit
            y_square = (x * x * x + curve.a * x + curve.b) % curve.p
            y = pow(y_square, (curve.p + 1) // 4, curve.p)
            if is_odd != (y & 1):
                y = -y % curve.p

            return Point(x, y, curve)
        else:
            s_bytes = bytes.fromhex(s)
            uncompressed = s_bytes[0] == 4
            if not uncompressed:
                raise ValueError("Only uncompressed or compressed points are supported")

            num_bytes = len(s_bytes) // 2
            x_bytes = s_bytes[1 : num_bytes + 1]
            y_bytes = s_bytes[num_bytes + 1 :]

            x = int.from_bytes(x_bytes, byteorder="big")
            y = int.from_bytes(y_bytes, byteorder="big")

            return Point(x, y, curve)

    def to_hex(self, compressed=True):
        if self.x is None and self.y is None:
            return "00"
        elif compressed:
            prefix = "03" if self.y & 1 else "02"
            return prefix + hex(self.x)[2:].zfill(64)
        else:
            x_hex = hex(self.x)[2:].zfill(64)
            y_hex = hex(self.y)[2:].zfill(64)
            return "04" + x_hex + y_hex

    @staticmethod
    def infinity(curve):
        return Point(None, None, curve)

# Define the ec_mul function
def ec_mul(point, scalar, base_point):
    result = Point.infinity(point.curve)
    addend = point

    while scalar:
        if scalar & 1:
            result += addend

        addend += addend
        scalar >>= 1

    return result

# Define the ec_operations function
def ec_operations(start_range, end_range, target_1, target_2, curve):
    # Define parameters for secp256k1 curve
    n = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
    G = Point(
        0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798,
        0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8,
        curve
    )

    # Open the files for writing
    with open("target1_division_results.txt", "a") as file1, \
            open("target2_division_results.txt", "a") as file2, \
            open("subtract_results.txt", "a") as file3:

        for i in range(start_range, end_range + 1):
            try:
                # Compute the inverse of i modulo n
                i_inv = pow(i, n-2, n)

                # Divide the targets by i modulo n
                result_1 = ec_mul(target_1, i_inv, G)
                result_2 = ec_mul(target_2, i_inv, G)

                # Subtract the results
                sub_result = result_2 - result_1

                # Write the results to separate files
                file1.write(f"{result_1.to_hex()}\n")
                file2.write(f"{result_2.to_hex()}\n")
                file3.write(f"Subtracting results for {i}:\n")
                file3.write(f"Target 1 / {i}: {result_1.to_hex()}\n")
                file3.write(f"Target 2 / {i}: {result_2.to_hex()}\n")
                file3.write(f"Subtraction: {sub_result.to_hex()}\n")
                file3.write("="*50 + "\n")

                print(f"Completed calculation for divisor {i}")
            except ZeroDivisionError:
                print(f"Error: division by zero for {i}")

    print("Calculation completed. Results saved in separate files.")

if __name__ == "__main__":
    # Set the targets and range for the operations
    curve = EllipticCurve(0, 7, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
    target_1 = Point.from_hex("0230210C23B1A047BC9BDBB13448E67DEDDC108946DE6DE639BCC75D47C0216B1B", curve)
    target_2 = Point.from_hex("02F6B787195159544330085C6014DBA627FF5B14F3203FF05D12482F76261F4FC3", curve)
    start_range = 2
    end_range = 200

    ec_operations(start_range, end_range, target_1, target_2, curve)

#include "SECP256k1.h"
#include "Point.h"
#include "sha256.h"
#include "Int.h"
#include "ripemd160.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

constexpr uint64_t START_VALUE = 576565752303423488ULL;
constexpr uint64_t END_VALUE = 900'000'000'000'000'000ULL;
constexpr uint64_t INCREMENT = 1ULL;

// Define a range of factors
constexpr double MIN_FACTOR = 64.0;
constexpr double MAX_FACTOR = 1028.0;
constexpr double FACTOR_INCREMENT = 1.00;

std::atomic currentValue(START_VALUE);
std::atomic totalKeys(0);
std::mutex printMutex;
std::mutex resultMutex;
std::vector> ripemd160Hashes;

std::chrono::time_point startTime;
std::atomic matchFound(false);
std::string currentHexPrivateKey;

void loadRIPEMD160Hashes() {
    std::ifstream file("wallets.txt");
    if (file.is_open()) {
        std::string hexHash;
        while (file >> hexHash) {
            if (hexHash.length() != 40) {
                std::cerr << "Invalid RIPEMD160 hash length: " << hexHash.length() << std::endl;
                continue; // Skip invalid hashes
            }

            std::array hash;
            for (int i = 0; i < 20; ++i) {
                std::string byteHex = hexHash.substr(2 * i, 2);
                hash[i] = static_cast(std::stoi(byteHex, nullptr, 16));
            }

            ripemd160Hashes.push_back(hash);
        }
        file.close();
        std::cout << "Loaded " << ripemd160Hashes.size() << " RIPEMD160 hashes from file." << std::endl;
    }
}

std::string hexBytesToHexString(const uint8_t* bytes, size_t length) {
    std::stringstream ss;
    ss << std::hex << std::setfill('0');
    for (size_t i = 0; i < length; ++i) {
        ss << std::setw(2) << static_cast(bytes[i]);
    }
    return ss.str();
}

bool hasMinimumMatchingCharacters(const uint8_t (&hash)[20]) {
    for (const std::array& loadedHash : ripemd160Hashes) {
        bool isMatch = true;
        for (int j = 0; j < 19; ++j) {  // Loop through the first 5 bytes (40 bits)
            if (hash[j] != loadedHash[j]) {
                isMatch = false;
                break; // If any character doesn't match, stop checking
            }
        }
        if (isMatch) {
            return true;
        }
    }
    return false;
}

void printProgress() {
    startTime = std::chrono::system_clock::now();

    while (!matchFound.load(std::memory_order_relaxed)) {
        {
            std::lock_guard lock(resultMutex);

            auto now = std::chrono::system_clock::now();
            auto elapsed = std::chrono::duration_cast(now - startTime);
            double keysPerSecond = static_cast(totalKeys.load()) / elapsed.count();

            std::cout << "\rTime: " << elapsed.count() << "s, Keys: " << totalKeys.load()
                      << ", Keys/s: " << std::fixed << std::setprecision(5) << keysPerSecond
                      << ", Current: " << currentValue.load()
                      << ", Priv Key: " << currentHexPrivateKey << std::flush;
        }
        std::this_thread::sleep_for(std::chrono::seconds(5));
    }
}

void counterWorker(int threadId, Secp256K1& secp256k1, int numThreads) {
    mpz_class current(START_VALUE + threadId * INCREMENT);

    while (current <= END_VALUE) {
        for (double factor = MIN_FACTOR; factor <= MAX_FACTOR; factor += FACTOR_INCREMENT) {
            mpz_class result = current * static_cast(factor);

            std::string hexPrivateKey = result.get_str(16); // Get hex representation directly
            currentHexPrivateKey = hexPrivateKey;

            Int privateKey;
            privateKey.SetBase16(hexPrivateKey.c_str());

            Point publicKey = secp256k1.ComputePublicKey(&privateKey);

            uint8_t compressedPublicKey[33];
            secp256k1.GetPublicKeyRaw(true, publicKey, reinterpret_cast(compressedPublicKey));

            uint8_t publicKeyHash[32];
            sha256_33(compressedPublicKey, publicKeyHash);

            uint8_t ripemd160Hash[20];
            ripemd160(publicKeyHash, 32, ripemd160Hash);

            if (hasMinimumMatchingCharacters(ripemd160Hash)) {
                std::string matchedPrivateKey = hexPrivateKey; // Store the private key for printing
                std::string matchedRipemd160 = hexBytesToHexString(ripemd160Hash, 20); // Convert RIPEMD160 to hex string

                {
                    std::lock_guard lock(printMutex);
                    std::cout << "\nMatching RIPEMD160 hash found. Private Key: " << matchedPrivateKey << ", RIPEMD160: " << matchedRipemd160 << std::endl;
                }

                {
                    std::ofstream foundFile("found.txt", std::ios::app); // Append mode
                    if (foundFile.is_open()) {
                        foundFile << "Matched Private Key: " << matchedPrivateKey << ", RIPEMD160: " << matchedRipemd160 << std::endl;
                        foundFile.close();
                    }
                }
            }
        }

        totalKeys.fetch_add(1);

        // Convert the mpz_class to uint64_t and update the currentValue atomically
        currentValue.store(static_cast(current.get_ui()), std::memory_order_relaxed);

        current += INCREMENT * numThreads;
    }

    // Signal that this thread has completed its work
    matchFound.store(true, std::memory_order_relaxed);
}

int main() {
    loadRIPEMD160Hashes();

    Secp256K1 secp256k1;
    secp256k1.Init();

    std::vector threads;

    // Start the progress printing thread
    std::thread progressThread(printProgress);

    const int numThreads = std::thread::hardware_concurrency();
    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(counterWorker, i, std::ref(secp256k1), numThreads);
    }

    for (auto& thread : threads) {
        thread.join();
    }

    // Wait for the progress thread to complete
    progressThread.join();

    std::cout << std::endl;

    return 0;
}

from sympy import mod_inverse

N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141

def ters(scalar, target):
    k = mod_inverse(2, N)
    scalar_bin = bin(scalar)[2:]
    for i in range(len(scalar_bin)):
        if scalar_bin[i] == '0':
            result = (target * k) % N
        else:
            result = ((target * k) % N + N - 1) % N
        target = result
    return result

target1 = 508467739815150526153708316710194877073
target2 = 73909945130129581315154379935980065

print("Target results:")
for x in range(1, 10):
    result1 = ters(x, target1)
    print(f"{x}-T1: {result1:x}")
for x in range(1, 10):
    result2 = ters(x, target2)
    print(f"{x}-T2: {result2:x}")
for x in range(1, 10):
    result1 = ters(x, target1)
    result2 = ters(x, target2)
    subtraction = (result1 - result2) % N
    print(f"{x}-Sub: {subtraction:x}")