I never trust other people's code. Only the programs I write myself are the most stable. Reward address: 1JWM1RsRFuct6y9JCwhx3TibvhDJVB2Ldn

import hashlib
import ecdsa
import base58
import threading
import logging

# 设置日志记录
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(threadName)s - %(message)s')

# 匹配的固定地址（写在代码中）
addresses_in_code = [
    "1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9",
    "1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ",
    "19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG",
    "19YZECXj3SxEZMoUeJ1yiPsw8xANe7M7QR",
    "1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU",
    "1JTK7s9YVYywfm5XUH7RNhHJH1LshCaRFR",
    "12VVRNPi4SJqUTsp6FmqDqY5sGosDtysn4"
]

# 生成私钥对应的比特币地址
def private_key_to_address(private_key_hex):
    private_key_bytes = bytes.fromhex(private_key_hex)
    signing_key = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
    verifying_key = signing_key.verifying_key
    pub_key = b'\x04' + verifying_key.to_string()  # 非压缩公钥格式

    # 计算公钥的哈希 (SHA256 + RIPEMD160)
    sha256_hash = hashlib.sha256(pub_key).digest()
    ripemd160_hash = hashlib.new('ripemd160', sha256_hash).digest()

    # 添加比特币网络前缀
    network_byte = b'\x00' + ripemd160_hash
    checksum = hashlib.sha256(hashlib.sha256(network_byte).digest()).digest()[:4]

    binary_address = network_byte + checksum
    return base58.b58encode(binary_address).decode()

# 按顺序递增生成私钥
def generate_private_keys_in_range(start_key_int, end_key_int):
    for key_int in range(start_key_int, end_key_int + 1):  # 递增 +1 生成私钥
        private_key_hex = format(key_int, '064x')
        yield private_key_hex

# 多线程生成私钥并匹配地址
def generate_and_match_private_keys(start_key_int, end_key_int):
    for private_key_hex in generate_private_keys_in_range(start_key_int, end_key_int):
        address = private_key_to_address(private_key_hex)

        # 匹配地址
        if address in addresses_in_code:
            logging.info(f"匹配成功: 私钥 {private_key_hex} 对应地址 {address}")
            # 匹配成功后立即写入 add.txt 文件
            with open('add.txt', 'a') as f_add:
                f_add.write(f"{private_key_hex},{address}\n")
        else:
            logging.info(f"未匹配: 私钥 {private_key_hex} 对应地址 {address}")

# 计算私钥区间的差值并划分成320份
def divide_key_range_into_parts(start_key, end_key, num_parts):
    start_int = int(start_key, 16)
    end_int = int(end_key, 16)
    total_range = end_int - start_int  # 修改为递增范围
    part_size = total_range // num_parts  # 每个线程的区间大小
    return [(start_int + i * part_size, start_int + (i + 1) * part_size - 1) for i in range(num_parts)]

# 启动320个线程，每个线程负责生成区间内的私钥
def start_threads_for_key_range(start_key, end_key, num_threads=320):
    key_ranges = divide_key_range_into_parts(start_key, end_key, num_threads)
   
    threads = []
    for i, (start_key_int, end_key_int) in enumerate(key_ranges):
        t = threading.Thread(target=generate_and_match_private_keys, args=(start_key_int, end_key_int), name=f"线程-{i+1}")
        threads.append(t)
        t.start()

    try:
        for t in threads:
            t.join()
    except KeyboardInterrupt:
        logging.info("捕获到 KeyboardInterrupt, 正在终止线程...")

# 主程序入口
if __name__ == "__main__":
    start_key = "00000000000000000000000000000000000000000000001b8f59c6c922e5426d"
    end_key = "00000000000000000000000000000000000000000000002c4221111a7294a017"
   
    try:
        # 启动320个线程，每个线程负责相应的私钥区间
        start_threads_for_key_range(start_key, end_key, num_threads=320)
    except KeyboardInterrupt:
        logging.info("程序手动终止")
        os._exit(0)