Quote from: mcdouglasx on Today at 06:24:13 PM

Quote from: mahmood1356 on Today at 11:53:55 AM

Prefixes [1PWo3JeB9j] identical to number800 If there is, does it have an impact on the target key search process?

The math is simple: for example, in a 4096-bit search space, an h160 prefix is found on average once. If this were frequent (2 out of 3 prefixes in 4096 bits), the hash function would be broken. That's why this is a good guide for probabilistic searches. Anyone who says otherwise is wrong.

It's not worth relying on addresses; you're just wasting resources.

Here's a script that shows you, without much fanfare, that prefix searching isn't as useless as some claim. Run it yourself and draw your own conclusions:

The Iceland module is required.

https://github.com/iceland2k14/secp256k1 The Iceland files must be in the same location where you saved this script. Some operating systems require Visual Studio Redistributables to be installed for it to work.

You can adjust the number of tests by setting total_runs = 100.

Code:

import random
import secp256k1 as ice
import concurrent.futures

# Configuration
START = 131071
END = 262143
BLOCK_SIZE = 4096
MIN_PREFIX = 3
MAX_WORKERS = 4
TOTAL_RUNS = 100

def generate_blocks(start, end, block_size):
   """
   Split the keyspace [start..end] into blocks of size block_size,
   then shuffle the block list for randomized dispatch.
   """
   total_keys = end - start + 1
   num_blocks = (total_keys + block_size - 1) // block_size
   blocks = [
   (start + i * block_size,
   min(start + (i + 1) * block_size - 1, end))
   for i in range(num_blocks)
   ]
   random.shuffle(blocks)
   return blocks

def scan_block(b0, b1, target):
   """
   Scan keys in [b0..b1] looking for target.
   Prune the block only if both conditions happen in order:
   1) A false positive on MIN_PREFIX hex chars
   2) Later, a match on the first MIN_PREFIX-1 hex chars
   """
   full_pref = target[:MIN_PREFIX]
   half_pref = target[:MIN_PREFIX - 1]

   for key in range(b0, b1 + 1):
   addr = ice.privatekey_to_h160(0, 1, key).hex()
   if addr == target:
   return True, key
   if addr.startswith(full_pref) and addr != target:
   next_key = key + 1
   break
   else:
   return False, None

   for key in range(next_key, b1 + 1):
   addr = ice.privatekey_to_h160(0, 1, key).hex()
   if addr == target:
   return True, key
   if addr.startswith(half_pref):
   break

   return False, None

def worker(block_chunk, target):
   """
   Scan each block in block_chunk sequentially.
   Return the key if found, else None.
   """
   for b0, b1 in block_chunk:
   found, key = scan_block(b0, b1, target)
   if found:
   return key
   return None

def parallel_scan(blocks, target):
   """
   Distribute blocks round-robin across MAX_WORKERS processes.
   Returns the discovered key or None.
   """
   chunks = [blocks[i::MAX_WORKERS] for i in range(MAX_WORKERS)]
   with concurrent.futures.ProcessPoolExecutor(max_workers=MAX_WORKERS) as executor:
   futures = [executor.submit(worker, chunk, target) for chunk in chunks]
   for future in concurrent.futures.as_completed(futures):
   key = future.result()
   if key is not None:
   for f in futures:
   f.cancel()
   return key
   return None

if __name__ == "__main__":
   found_count = 0
   not_found_count = 0

   for run in range(1, TOTAL_RUNS + 1):
   target_key = random.randint(START, END)
   target = ice.privatekey_to_h160(0, 1, target_key).hex()

   blocks = generate_blocks(START, END, BLOCK_SIZE)
   key = parallel_scan(blocks, target)

   if key is not None:
   found_count += 1
   else:
   not_found_count += 1

   print(f"\nOf {TOTAL_RUNS} runs, found: {found_count}, not found: {not_found_count}")

R: Of 100 runs, found: 67, not found: 33

If you reduce the block size by 25% BLOCK_SIZE = 3072 your success percentage will obviously increase, but it will involve covering more space to increase your success rate.

r:Of 100 runs, found: 78, not found: 22

Therefore, searching for prefixes is the best method as long as you are not trying to scan the entire range (just try your luck).

Disclaimer for the know-it-alls: yes, the code is partially done with AI but it is completely correct.

But your simple math forgets math Cheesy

1 An h160 is 40 hex digits; matching just 3 gives you a 1 in 4096 filter.
2 Your script already knows the target key sits in a tiny 131 k value window: rigged lotto, congrats.
3 A 67% hit rate when the fish is trapped in the bowl only shows your heuristic is shaky; at the real scale (2^256 keys) that boost rounds to 0.000%.
4 If 2/3 of prefixes really repeated, SHA-256 would be broken, so yet you use it to “prove” it’s secure. That’s some top-tier circular logic.

Scanning prefixes in a kiddie pool proves nothing except your confusion between a demo and Python sleight of hand.