Quote from: yoshimitsu777 on Today at 11:56:11 AM

Quote from: arulbero

randbelow(n-1)+1

how to replace this line

Code:

private_keys = list(map(secrets.randbelow,n))

Try this code:

Code:

#!/usr/bin/env python3
# 2023/Jan/01, citb0in_multicore_secrets.py
import concurrent.futures
import os
import secrets
import secp256k1 as ice

# how many cores to use
num_cores = 10
#num_cores = os.cpu_count()

# Set the number of addresses to generate
num_addresses = 10000000

# Define a worker function that generates a batch of addresses and returns them
def worker(start, end, i):

# Generate a list of random private keys using "secrets" library
n = [0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141] * (end - start) #n
one = [1] * (end - start)
my_secure_rng = secrets.SystemRandom()
private_keys = list(map(my_secure_rng.randrange,one,n)) #from 1 to n-1

# Use secp256k1 to convert the private keys to addresses
addr_type = [2] * (end - start)
is_compressed = [True] * (end - start)
thread_addresses = list(map(ice.privatekey_to_address, addr_type, is_compressed, private_keys))

# Write the addresses in the thread file
f = open("addresses_1M_multicore_secrets" + str(i) + ".txt", "w")
list(map(lambda x:f.write(x+"\n"),thread_addresses))
#or, if you want to store private keys too
#list(map(lambda x,y: f.write('%s -> %s\n' % (hex(x)[2:].rjust(64,'0'), y)),private_keys,thread_addresses))
f.close()

return

# 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, i))