def send_and_receive_line(host, port, message):
    # Create a TCP socket
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    try:
        # Connect to the server
        sock.connect((host, port))

        # Send the message
        start_time = time.time()
        sock.sendall(message.encode())

        # Receive the reply
        reply = sock.recv(1024).decode()
        end_time = time.time()

        # Calculate the elapsed time
        elapsed_time = end_time - start_time
        sock.close()
        return reply, elapsed_time
    except ConnectionResetError:
        print("Server closed the connection without replying.")
        return None, None
    except ConnectionRefusedError:
        print("Connection refused. Make sure the server is running and the host/port are correct.")
        return None, None
    except AttributeError:
        return None, None

def keyhunt_client(target):
    host = 'localhost'  # Change this to the server's hostname or IP address
    port = 8080       # Change this to the server's port number
    message = "{} {}:{}".format(target["publickey"],target["start"],target["end"])
    reply, elapsed_time = send_and_receive_line(host, port, message)
    if( reply != "404 Not Found"): 
        return reply
    else:
        return None

This is the public key: 0291bee5cf4b14c291c650732faa166040e4c18a14731f9a930c1e87d3ec12debb

 Building the Binary Database

 Targeting PubKey:      0291bee5cf4b14c291c650732faa166040e4c18a14731f9a930c1e87d3ec12debb
 Number of PubKeys:     60,000,000
 Writing to file every: 60,000,000 keys
 Subtract Value:        1
 Space Covered:        60,000,000 / 0x3938700

DB Generation Time:  0:00:31.915161

 Scanning Incrementally (BSGS?! Maybe Meet In The Middle?)

 Current Key Position:  0x8000d693a3e2   Jumps Made:  30
PK Found: 191206974700443
PK Found: 0xade6d7ce3b9b


Search Time:  0:00:01.605224

Total Time:  0:00:01.606917

#by mcdouglasx
import secp256k1 as ice
from bitstring import BitArray

print("creating Baby Step")


#create baby step

num = 2000000 # Keys number in Binary Babystep. same m in search script

Low_m= 20

lm= num // Low_m

Add = 1
Add_pub= ice.scalar_multiplication(Add)

res= ice.point_sequential_increment(lm, Add_pub)

binary = ''
for t in range (lm):

    h= (res[t*65:t*65+65]).hex()
    hc= int(h[2:], 16)
        
        
    if str(hc).endswith(('0','2','4','6','8')):
        A="0"
        binary+= ''.join(str(A))
            
    if str(hc).endswith(('1','3','5','7','9')):
        A="1"
        binary+= ''.join(str(A))
        

my_str = (BitArray(bin=binary))#bin=binary

binary_file = open('baby_steps__binary.bin', 'ab')
my_str.tofile(binary_file)
binary_file.close()

for i in range (1,Low_m):
    print("stage: "+ str(i+1)+"/"+str(20))
    
    lm_upub= ice.scalar_multiplication((lm*i))

    res= ice.point_sequential_increment(lm, lm_upub)

    binary = ''
    for t in range (lm):

        h= (res[t*65:t*65+65]).hex()
        hc= int(h[2:], 16)
            
            
        if str(hc).endswith(('0','2','4','6','8')):
            A="0"
            binary+= ''.join(str(A))
                
        if str(hc).endswith(('1','3','5','7','9')):
            A="1"
            binary+= ''.join(str(A))
            

    my_str = (BitArray(bin=binary))#bin=binary

    binary_file = open('baby_steps__binary.bin', 'ab')
    my_str.tofile(binary_file)
    binary_file.close()

start_key = 1
num_public_keys = 2**50 
bits_to_store = 64
bytes_to_store = bits_to_store//8
rate_of_key_to_generate = 2**24

#!/usr/bin/env python3
# 2023/Dec/03, arulbero_pub_key.py
import secp256k1 as ice

#############################################################################
# Set the number of public keys to generate and other parameters
#############################################################################
start_key = 1
num_public_keys = 32000000
bits_to_store = 64
bytes_to_store = bits_to_store//8
rate_of_key_to_generate = 64
rate_of_key_to_store = rate_of_key_to_generate

interval_to_generate = range(start_key,num_public_keys+1, rate_of_key_to_store)

interval_to_store = range(start_key,num_public_keys+1,rate_of_key_to_store)

binary_mode = 1

#private_keys = list(interval_to_generate)

#############################################################################


if (binary_mode == 1):

	f = open("public_keys_database.bin", "wb") #binary mode

	###########generation#################
	public_keys=[] 
	
	for i in interval_to_generate:                 #generate the other keys
		P = ice.scalar_multiplication(i)
		public_keys.append(P[33-bytes_to_store:33].hex())

	###########writing the db###############
	for i in range(0,len(interval_to_store)):
		h = int(public_keys[i],16)
		f.write(h.to_bytes(bytes_to_store,byteorder='big'))
		
	f.close()
	
else:

	f = open("public_keys_database.txt", "w")
	
	###########generation#################
	public_keys=[] 
	
	for i in interval_to_generate:
		P = ice.scalar_multiplication(i)
		public_keys.append(P[33-bytes_to_store:33].hex())

	###########writing the db###############
	for i in range(0,len(interval_to_store)):
		h = public_keys[i]
		f.write(h)
	f.close()

#@mcdouglasx
import secp256k1 as ice
from bitstring import BitArray
import bitcoin


print("Making Binary Data-Base")


target_public_key = "0230210c23b1a047bc9bdbb13448e67deddc108946de6de639bcc75d47c0216b1b"

target = ice.pub2upub(target_public_key)


num = 2000000000 # number of keys.

sustract = 1 #amount to subtract each time.

Low_m= 200

#2^28 / 2^ 26 = 4
#2^29 / 2^26 = 8
#2^30 / 2^26 = 16
#2^32 / 2^26 = 64

lm= num // Low_m
   

sustract_pub= ice.scalar_multiplication(sustract)

res= ice.point_loop_subtraction(lm, target, sustract_pub)
binary = ''
for t in range (lm):

    h= (res[t*65:t*65+65]).hex()
    hc= int(h[2:], 16)
        
        
    if str(hc).endswith(('0','2','4','6','8')):
        A="0"
        binary+= ''.join(str(A))
            
    if str(hc).endswith(('1','3','5','7','9')):
        A="1"
        binary+= ''.join(str(A))
        

my_str = bytes(BitArray(bin=binary))

binary_file = open('130Bit.bin', 'wb')
binary_file.write(my_str)
binary_file.close()

for i in range (1,Low_m):
    
    mem= ice.to_cpub(ice.scalar_multiplication(lm).hex())
    
    Apk= bitcoin.multiply(mem, i)
    
    Apk_upu= ice.pub2upub(Apk)

    A1= ice.point_addition(target, Apk_upu)

    sustract_pub= ice.scalar_multiplication(sustract)

    res= ice.point_loop_subtraction(lm, A1, sustract_pub)
    
    binary = ''
    for t in range (lm):

        h= (res[t*65:t*65+65]).hex()
        hc= int(h[2:], 16)
            
            
        if str(hc).endswith(('0','2','4','6','8')):
            A="0"
            binary+= ''.join(str(A))
                
        if str(hc).endswith(('1','3','5','7','9')):
            A="1"
            binary+= ''.join(str(A))
            

    my_str = bytes(BitArray(bin=binary))

    binary_file = open('65Bit.bin', 'ab')
    binary_file.write(my_str)
    binary_file.close()