Quote from: b0dre on Today at 07:00:43 PM

Quote from: Denevron on Today at 04:25:31 PM

Quote from: b0dre on Today at 04:16:52 PM

Quote from: nomachine on Today at 01:47:29 PM

Quote from: Denevron on Today at 12:29:24 PM

Quote from: nomachine on Today at 12:18:24 PM

Quote from: Denevron on Today at 12:04:50 PM

can be called a mutagen Grin

It's not that simple, but it speeds up the process, you've noticed it yourself)

you can add it to Cyclon as a new method, and there you just don’t calculate the puzzle range, but enter the key by which the bits will change, and it’s better not in random mode, but in sequential mode, because the random mode will loop and that’s it, and you will be forever, say, chasing in 30 bits, and you won’t find it, and it will be, say, in 33 bits

Code:

import time
import multiprocessing
import secp256k1 as ice
import random
from math import comb
import numpy as np

# Configuration
TARGET_ADDR = "1HsMJxNiV7TLxmoF6uJNkydxPFDog4NQum" # Puzzle 20
BASE_KEY = "000000000000000000000000000000000000000000000000000000000005749f" # Puzzle 19 Private Key
PUZZLE_NUM = 20
WORKERS = multiprocessing.cpu_count()

# Historical flip counts
FLIP_TABLE = {
20:8, 21:8, 22:9, 23:9, 24:10, 25:11, 26:12, 27:13, 28:14, 29:15,
30:16, 31:17, 32:18, 33:19, 34:20, 35:21, 36:22, 37:23, 38:24, 39:25,
40:26, 41:27, 42:28, 43:29, 44:30, 45:31, 46:32, 47:33, 48:34, 49:35,
50:36, 51:37, 52:38, 53:39, 54:40, 55:41, 56:42, 57:43, 58:44, 59:45,
60:46, 61:47, 62:48, 63:49, 64:50, 65:51, 66:52, 67:53
}

def predict_flips(puzzle_num):
"""Predict flip count using linear regression with bounds"""
if puzzle_num in FLIP_TABLE:
return FLIP_TABLE[puzzle_num]

# Linear regression
x = np.array(list(FLIP_TABLE.keys()))
y = np.array(list(FLIP_TABLE.values()))
coeffs = np.polyfit(x, y, 1)
predicted = round(coeffs[0] * puzzle_num + coeffs[1])

# Apply bounds (50-60% of bits)
bit_length = puzzle_num
lower = max(8, int(bit_length * 0.5))
upper = min(int(bit_length * 0.6), bit_length-5)
return min(max(predicted, lower), upper)

def mutate_key(base_int, flip_positions):
"""Ultra-fast bit flipping using XOR mask"""
flip_mask = sum(1 << bit for bit in flip_positions)
return base_int ^ flip_mask

def worker(base_int, bit_length, flip_count, results, stop_event):
checked = 0
bit_positions = list(range(bit_length))
start_time = time.time()

while not stop_event.is_set():
# Generate random flip positions
flip_pos = random.sample(bit_positions, flip_count)

# Create mutated key
priv_int = mutate_key(base_int, flip_pos)
checked += 1

# Generate address
addr = ice.privatekey_to_address(0, True, priv_int)

if addr == TARGET_ADDR:
hex_key = "%064x" % priv_int
actual_flips = bin(base_int ^ priv_int).count('1')
results.put((hex_key, checked, actual_flips))
stop_event.set()
return

# Progress update
if checked % 10000 == 0:
elapsed = time.time() - start_time
speed = checked/elapsed if elapsed > 0 else 0
print(f"Checked {checked:,} | {speed:,.0f} keys/sec", end='\r')

def parallel_search():
bit_length = PUZZLE_NUM
base_int = int(BASE_KEY, 16)
flip_count = predict_flips(PUZZLE_NUM)
total_combs = comb(bit_length, flip_count)

print(f"\nSearching Puzzle {PUZZLE_NUM} (256-bit)")
print(f"Base Key: {BASE_KEY}")
print(f"Target: {TARGET_ADDR}")
print(f"Predicted Flip Count: {flip_count} bits")
print(f"Total Possible Combinations: 2^{int(np.log2(total_combs)):,}")
print(f"Using {WORKERS} workers...\n")

manager = multiprocessing.Manager()
results = manager.Queue()
stop_event = manager.Event()

start_time = time.time()

with multiprocessing.Pool(WORKERS) as pool:
for _ in range(WORKERS):
pool.apply_async(worker, (base_int, bit_length, flip_count, results, stop_event))

try:
hex_key, checked, actual_flips = results.get(timeout=86400) # 24h timeout
stop_event.set()

elapsed = time.time() - start_time
print(f"\nFound in {elapsed/3600:.2f} hours")
print(f"Private Key: {hex_key}")
print(f"Actual Bit Flips: {actual_flips}")
print(f"Keys Checked: {checked:,}")
print(f"Speed: {checked/elapsed:,.0f} keys/sec")

solution_file = f"puzzle_{PUZZLE_NUM}_solution.txt"
with open(solution_file, "w") as f:
f.write(hex_key)
print(f"\nSolution saved to {solution_file}")
return hex_key

except:
print("\nKey not found in 24 hours - try adjusting flip count ±2")
return None
finally:
pool.terminate()

if __name__ == "__main__":
flip_count = predict_flips(PUZZLE_NUM) # First calculate flip_count
print(f"Predicted flip count for {PUZZLE_NUM}: {flip_count} bits")
solution = parallel_search()

Here is my Python version.
I still think this is useless. If someone convinces me otherwise. Grin

you don't need to use random, so you won't find a match, only if you guess the number of bits Cheesy

Code:

import time
import multiprocessing
import secp256k1 as ice
from math import comb
import numpy as np
from itertools import combinations # For sequential flip generation

# Configuration
TARGET_ADDR = "1HsMJxNiV7TLxmoF6uJNkydxPFDog4NQum" # Puzzle 20
BASE_KEY = "000000000000000000000000000000000000000000000000000000000005749f" # Puzzle 19 Private Key
PUZZLE_NUM = 20
WORKERS = multiprocessing.cpu_count()

# Historical flip counts (unchanged)
FLIP_TABLE = {
   20:8, 21:8, 22:9, 23:9, 24:10, 25:11, 26:12, 27:13, 28:14, 29:15,
   30:16, 31:17, 32:18, 33:19, 34:20, 35:21, 36:22, 37:23, 38:24, 39:25,
   40:26, 41:27, 42:28, 43:29, 44:30, 45:31, 46:32, 47:33, 48:34, 49:35,
   50:36, 51:37, 52:38, 53:39, 54:40, 55:41, 56:42, 57:43, 58:44, 59:45,
   60:46, 61:47, 62:48, 63:49, 64:50, 65:51, 66:52, 67:53
}

def predict_flips(puzzle_num):
   """Predict flip count using linear regression with bounds (unchanged)"""
   if puzzle_num in FLIP_TABLE:
   return FLIP_TABLE[puzzle_num]

   # Linear regression
   x = np.array(list(FLIP_TABLE.keys()))
   y = np.array(list(FLIP_TABLE.values()))
   coeffs = np.polyfit(x, y, 1)
   predicted = round(coeffs[0] * puzzle_num + coeffs[1])

   # Apply bounds (50-60% of bits)
   bit_length = puzzle_num
   lower = max(8, int(bit_length * 0.5))
   upper = min(int(bit_length * 0.6), bit_length-5)
   return min(max(predicted, lower), upper)

def mutate_key(base_int, flip_positions):
   """Ultra-fast bit flipping using XOR mask (unchanged)"""
   flip_mask = sum(1 << bit for bit in flip_positions)
   return base_int ^ flip_mask

def worker(base_int, bit_length, flip_count, results, stop_event, start_index, end_index):
   """Modified worker for sequential search"""
   checked = 0
   bit_positions = list(range(bit_length))
   start_time = time.time()

   # Generate all combinations in the assigned range
   all_combinations = combinations(bit_positions, flip_count)

   # Skip to the start index (for parallelization)
   for _ in range(start_index):
   next(all_combinations, None)

   # Iterate through combinations sequentially
   for flip_pos in all_combinations:
   if stop_event.is_set():
   return

   if checked >= (end_index - start_index):
   return

   priv_int = mutate_key(base_int, flip_pos)
   checked += 1

   # Generate address
   addr = ice.privatekey_to_address(0, True, priv_int)

   if addr == TARGET_ADDR:
   hex_key = "%064x" % priv_int
   actual_flips = bin(base_int ^ priv_int).count('1')
   results.put((hex_key, checked, actual_flips))
   stop_event.set()
   return

   # Progress update
   if checked % 10000 == 0:
   elapsed = time.time() - start_time
   speed = checked/elapsed if elapsed > 0 else 0
   print(f"Checked {checked:,} | {speed:,.0f} keys/sec", end='\r')

def parallel_search():
   bit_length = PUZZLE_NUM
   base_int = int(BASE_KEY, 16)
   flip_count = predict_flips(PUZZLE_NUM)
   total_combs = comb(bit_length, flip_count)

   print(f"\nSearching Puzzle {PUZZLE_NUM} (256-bit)")
   print(f"Base Key: {BASE_KEY}")
   print(f"Target: {TARGET_ADDR}")
   print(f"Predicted Flip Count: {flip_count} bits")
   print(f"Total Possible Combinations: 2^{int(np.log2(total_combs)):,}")
   print(f"Using {WORKERS} workers...\n")

   manager = multiprocessing.Manager()
   results = manager.Queue()
   stop_event = manager.Event()

   start_time = time.time()

   # Split work into chunks for each worker
   chunk_size = total_combs // WORKERS
   ranges = [(i * chunk_size, (i + 1) * chunk_size) for i in range(WORKERS)]

   with multiprocessing.Pool(WORKERS) as pool:
   for start, end in ranges:
   pool.apply_async(worker, (base_int, bit_length, flip_count, results, stop_event, start, end))

   try:
   hex_key, checked, actual_flips = results.get(timeout=86400) # 24h timeout
   stop_event.set()

   elapsed = time.time() - start_time
   print(f"\nFound in {elapsed/3600:.2f} hours")
   print(f"Private Key: {hex_key}")
   print(f"Actual Bit Flips: {actual_flips}")
   print(f"Keys Checked: {checked:,}")
   print(f"Speed: {checked/elapsed:,.0f} keys/sec")

   solution_file = f"puzzle_{PUZZLE_NUM}_solution.txt"
   with open(solution_file, "w") as f:
   f.write(hex_key)
   print(f"\nSolution saved to {solution_file}")
   return hex_key

   except:
   print("\nKey not found in 24 hours - try adjusting flip count ±2")
   return None
   finally:
   pool.terminate()

if __name__ == "__main__":
   flip_count = predict_flips(PUZZLE_NUM)
   print(f"Predicted flip count for {PUZZLE_NUM}: {flip_count} bits")
   solution = parallel_search()

Here is the script. I don't see any difference here. To solve puzzle 68 you need impossible speed.

21 is not found!

For 21 you need to put the key from the 20th puzzle, set hash160 from 21 and put 9 bits - then you will find) those bits that are in the nomachine example, this is just an example, this is not the exact number of bits that need to be changed) Grin

Found, but now 22 is not.

you need a key from 21 and hash160 from 22, and set the required number of bits, which in your opinion should be suitable, this is 11 bits)