Quote from: nikolayspb on Today at 12:02:50 AM

For your Google collab try that

!pip install coincurve pycryptodome bloom-filter2

import time
import hashlib
from coincurve import PrivateKey
from Crypto.Hash import RIPEMD160
import os
import sys
from bloom_filter2 import BloomFilter
from google.colab import drive
import signal

# Mount Google Drive
drive.mount('/content/drive')

# Config
FILE_NAME = "Puzzle 71.013.000.csv"
DRIVE_FOLDER = "/content/drive/MyDrive/Puzzle71"
file_path = f"{DRIVE_FOLDER}/{FILE_NAME}"
SCAN_RANGE = 100_000
TARGET_PREFIX = "f6f543"
BLOOM_CAPACITY = 1_000_000
BLOOM_ERROR_RATE = 0.001

# Load known H160 hashes into Bloom filter
KNOWN_H160S = [
"f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8",
]
bloom = BloomFilter(max_elements=BLOOM_CAPACITY, error_rate=BLOOM_ERROR_RATE)
for h in KNOWN_H160S:
bloom.add(h)

# Read decimal numbers from CSV
with open(file_path, 'r') as f:
lines = [line.strip() for line in f if line.strip()]
if lines[0].lower().startswith('value'):
lines = lines[1:]
decimal_numbers = [int(line) for line in lines]

def privatekey_to_h160(priv_key_int):
try:
priv = PrivateKey.from_int(priv_key_int)
pubkey = priv.public_key.format(compressed=True)
sha256 = hashlib.sha256(pubkey).digest()
ripemd160 = RIPEMD160.new(sha256).digest()
return ripemd160.hex()
except Exception:
return None

def signal_handler(sig, frame):
print("\n[!] Interrupted. Exiting.")
sys.exit(0)

def check_key(k):
h160 = privatekey_to_h160(k)
if h160 and (h160.startswith(TARGET_PREFIX) or h160 in bloom):
return ('match', k, h160)
return ('progress', k, h160)

def process_decimal(decimal):
import multiprocessing as mp

start = max(1, decimal - SCAN_RANGE)
end = decimal + SCAN_RANGE
keys = list(range(start, end + 1))

processed = 0
start_time = time.time()
last_key = None
last_h160 = None

ctx = mp.get_context("spawn") # Colab-safe
with ctx.Pool(processes=os.cpu_count()) as pool:
result_iter = pool.imap_unordered(check_key, keys, chunksize=1000)

for result in result_iter:
if result[0] == 'match':
_, key, h160 = result
print(f"\n**PREFIX MATCH FOUND!** Private key {hex(key)} produces Hash160: {h160}\n")
elif result[0] == 'progress':
_, key, h160 = result
processed += 1
last_key = key
last_h160 = h160

elapsed = time.time() - start_time
speed = processed / elapsed if elapsed > 0 else 0
print(f"\nHash160 of the last processed key {hex(last_key)} -> {last_h160}")
print(f"[✓] Completed Decimal: {decimal} - Processed {processed} keys in {elapsed:.2f}s (Speed: {speed:.2f} keys/sec)")

def main():
signal.signal(signal.SIGINT, signal_handler)

print(f"\nLoaded {len(decimal_numbers)} Decimal numbers.")
print(f"Scanning ±{SCAN_RANGE} around each.\nTarget prefix: {TARGET_PREFIX}")
print(f"Bloom filter contains {len(KNOWN_H160S)} known H160 hashes.\n")

Try that

In Colab, the CPU does the heavy lifting by default—Tesla T4 GPU remains mostly idle because bigint cryptography operations are rarely GPU-accelerated.

However, using coincurve combined with multiprocessing, Colab can squeeze maximum performance out of the CPU (usually 2 to 4 cores).