@AlexanderCurl, regarding sequential key generation:
Have you tried adding a large prime number, like 0xdeadbeef (just an example, I don't even know if that's prime)?
Sure, you'll have to check for overflow more frequently - fortunately, that's just a matter of doing a Greater-Than comparison followed by a subtraction - but a sufficiently large increment should make the keys look pseudorandom as far as the bits are concerned.
Have no idea what you are talking about. On my computer i use VanitySearch code on a daily basis for all types of programs.(random, sequential, whatever)
Whoops, now that I checked again, it turns out that I was referring to a post written by
@citboin. Sorry for the misunderstanding.
...
Well, so far so good. I showed this just to summarize things up. Afterwards I modified my code according to your suggestion so the private keys are not generated randomly but instead they are sequentially generated from a pre-defined starting point. Here's the modified version:
#!/usr/bin/env python3
# 2022/Dec/26, [b]citb0in_seq.py[/b]
import concurrent.futures
import os
import numpy as np
import secp256k1 as ice
# how many cores to use
num_cores = 1
#num_cores = os.cpu_count()
# Number of addresses to generate
num_addresses = 1000000
# Starting point (decimal/integer) for private key
starting_point = 123456789
# Define a worker function that generates a batch of addresses and returns them
def worker(start, end, starting_point):
# Initialize the private key to the starting point
private_key = starting_point
# Initialize the list to hold to private keys
private_keys = []
# Generate a batch of private keys sequentially
for i in range(start, end):
# Increment the private key
private_key += 1
# Add the private key to the list
private_keys.append(private_key)
# Use secp256k1 to convert the private keys to addresses
thread_addresses = np.array([ice.privatekey_to_address(2, True, dec) for dec in private_keys])
return thread_addresses
#return (thread_addresses, private_keys, start_int)
# Use a ProcessPoolExecutor to generate the addresses in parallel
with concurrent.futures.ProcessPoolExecutor() as executor:
# Divide the addresses evenly among the available CPU cores
addresses_per_core = num_addresses // num_cores
# Submit a task for each batch of addresses to the executor
tasks = []
for i in range(num_cores):
start = i * addresses_per_core
end = (i+1) * addresses_per_core
tasks.append(executor.submit(worker, start, end, starting_point))
# Wait for the tasks to complete and retrieve the results
addresses = []
for task in concurrent.futures.as_completed(tasks):
addresses.extend(task.result())
# Write the addresses to a file
np.savetxt('addresses_1M_seq_singlecore.txt', addresses, fmt='%s')
...
To save eyes from being burnt by screens at 11PM, I will paste the relevant part of the codebhwre:
# Starting point (decimal/integer) for private key
starting_point = 123456789
# Define a worker function that generates a batch of addresses and returns them
def worker(start, end, starting_point):
# Initialize the private key to the starting point
private_key = starting_point
# Initialize the list to hold to private keys
private_keys = []
# Generate a batch of private keys sequentially
for i in range(start, end):
# Increment the private key
private_key += 1 #TODO why not use a large prime number instead of 1? 1 is not random at all, but a few dozen bits varying at once can be made to look random to others.