Bitcoin puzzle transaction ~32 BTC prize to who solves it

[nomachine]

hows this one? ready for some fun?   THIS ONE SCRIPT IS SEARCHING FOR PUZZLES 66 -71 from a single hex which is 20000000000000000...2ffffffffffffffff. I can also adjust the step size.

Code:

import os, random, secrets, hashlib, ecdsa

# List of target Hash 160 values to search for
target_public_key_hashes = [
    bytes.fromhex('20d45a6a762535700ce9e0b216e31994335db8a5'),
    bytes.fromhex('739437bb3dd6d1983e66629c5f08c70e52769371'),
    bytes.fromhex('e0b8a2baee1b77fc703455f39d51477451fc8cfc'),
    bytes.fromhex('61eb8a50c86b0584bb727dd65bed8d2400d6d5aa'),
    bytes.fromhex('f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8'),
]

while True:
    dec = secrets.SystemRandom().randrange(36893488147419103231, 2361183241434822606847)
    private_key_bytes = (b'\x00' * 32)[:-len(dec.to_bytes((dec.bit_length() + 7) // 8, 'big'))] + dec.to_bytes((dec.bit_length() + 7) // 8, 'big')
    signing_key = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
    h160 = hashlib.new('ripemd160', hashlib.sha256(signing_key.get_verifying_key().to_string("compressed")).digest()).digest()   
    if h160 in target_public_key_hashes:
        dec = int.from_bytes(full_bytes, byteorder='big')
        print(f"Found match with hash {h160.hex()}. Decoded value: {dec}")
        target_public_key_hashes.remove(h160)  # Remove the found hash from the list
        if not target_public_key_hashes:
            print("All target hashes found.")
            break

The same goal, only simplified.

[Woz2000]

He said it was from keyhunt, so unless he modified it, its straight brute force as pub key is not available for 66.

QUOTE:
"CPU (keyhunt)
Total 50247107966976 keys in 10095 seconds: ~4 Gkeys/s (4977425256 keys/s)

GPU (bitcrack)
NVIDIA GeForce R / 24217MB | 1 target 3307.00 MKey/s (11,423,035,949,056 total) [00:56:47]"

How is that i9 able to outperform the 4090 in straight brute forcing?

It depends on what the script calculates and how it calculates.
Are only compressed keys counted or all together? Is it a key or a hash?
Which parameters do you use in one script and which in the other? (user input)*
You can practice in Python to see how counting works.
...deleted...

Let's say in raw Python you can achieve about 3.98 MHash/s on 12 cores

• Fri Oct 27 10:06:46 2023
• Puzzle = 66
• Ending characters missing: 18
• Public Key Hash (Hash 160): 20d45a6a762535700ce9e0b216e31994335db8a5
• Hashes per second: 3.98 MHash/s

In the same Python with the kangaroo algorithm I have about 50 MKeys/s (if you count jumps)


In C++ everything is 10 or 100 times more (if is GPU).

What exactly is counted depends on which algorithm was used  and how is used.

*It even depends on how it is compiled for which platform - for example: AMD Ryzen 9 7950X3D

Code:

gcc -Q -march=native --help=target | grep -E '^\s+-.*(sse|march)'

g++ -m64 -march=native -mtune=native -msse4.2 -pthread -O3 -I. -o ...etc...

The presence of SSE4.1 and SSE4.2 instruction sets can be particularly beneficial for cryptographic operations, as they include instructions that can accelerate certain mathematical operations required for SECPK1 calculations.
You can experiment with these flags for cryptographic workloads.

Effectiveness of this flag depends on the specific algorithms and code you are working with. It's a good practice to benchmark code with and without the flag.

[nomachine]

He said it was from keyhunt, so unless he modified it, its straight brute force as pub key is not available for 66.

You're right. I can achieve a maximum of ~1 Ekeys/s with AMD Ryzen 9 7950X3D, but if I know what public key is.

• Version 0.2.230519 Satoshi Quest, developed by AlbertoBSD
• Random mode
• K factor 512
• Search compress only
• Endomorphism enabled
• Threads : 16
• Stats output every 20 seconds
• Quiet thread output
• Mode BSGS random
• Opening file tests/130.txt
• Added 1 points from file
• Bit Range 130
• -- from : 0x200000000000000000000000000000000
• -- to   : 0x400000000000000000000000000000000
• N = 0x400000000000
• Bloom filter for 4294967296 elements : 14722.65 MB
• Bloom filter for 134217728 elements : 460.08 MB
• Bloom filter for 4194304 elements : 14.38 MB
• Allocating 64.00 MB for 4194304 bP Points
• Reading bloom filter from file keyhunt_bsgs_4_4294967296.blm .... Done!
• Reading bloom filter from file keyhunt_bsgs_6_134217728.blm .... Done!
• Reading bP Table from file keyhunt_bsgs_2_4194304.tbl .... Done!
• Reading bloom filter from file keyhunt_bsgs_7_4194304.blm .... Done!
• Total 22924448003222667264 keys in 20 seconds: ~1 Ekeys/s (1146222400161133363 keys/s)

I just modified the Makefile to have -msse4.2 .
If I don't know what public key is, the speed cannot be higher than 50 MKey/s. . .

Theoretically it could get closer... If you have a 128 Core
https://www.titancomputers.com/Titan-A475-Dual-AMD-EPYC-Milan-7003-Series-Proce-p/a475.htm

[mcdouglasx]

Hello, is this what you need?

Hi, it's close but not so much, here is the logic:

Target = 3487790154155768 now if we subtract 99 G from it, on our 68th subtraction we will land on 3487790154155700, then we can divide it by 100, to get 34877901541557 now with this new key our 57th subtraction lands on  34877901541500 , then we divide it by 100 to get 348779015415 , but since we don't know which key is what, we would consider our target as 100 then by subtracting G 99 times from it, we will have 100 keys, 1, 2, 3, 4, ...........100. We divide and index them in order, like:
Target(100)/100 = 100/100, 99(which is -1 of our target)/100, 98/100, 97/100. We don't save them all, we just specify that we want our target to be divided by 100 for 30 times in a *row and it keeps doing that.

We just need to divide our key by 100, for 2 or 3 times as a test.

I understand your logic, it seems like a very good idea. I'll put myself into it to clear my mind, I've been very busy because my mother has health problems and I've been working on other things, but on paper your proposal is interesting

Edit: you will need 100^20, It would be just like going through the entire range.

[MoreForUs]

The same goal, only simplified.

simplified..but you're pulling hashes from all over. this seems like it will take forever to find a match. even with impressive speed. 0000000000000000000000000000000000000000000000c856c4ca3cb9c8766e
Iteration 133394: Generated hash 04133ae3a72b383457c8116a13a8f6fe12236ced
Private Key Hex: 0000000000000000000000000000000000000000000000c85509b05931fa7e0f
Iteration 133395: Generated hash 5503e52f2f7b052b7f0d06680931e1e5f7dc72bf
Private Key Hex: 0000000000000000000000000000000000000000000000c5783688057c9ff90e
Iteration 133396: Generated hash dea497f05ab93a4cd82c04b7042e8909cb71ed86
Private Key Hex: 00000000000000000000000000000000000000000000002bfa3a7bcb95a6bda1
Iteration 133397: Generated hash 4924746a8c9c8d0de3598cecd6a12005579b4c75
Private Key Hex: 0000000000000000000000000000000000000000000000c8c0e47fd806b23588
Iteration 133398: Generated hash 31c10fc8c9584b7d454e191f7ba046f171ea5ebc
Private Key Hex: 00000000000000000000000000000000000000000000004d1d18f8ba61efb1c9
Iteration 133399: Generated hash b6c3e00fdc24f63f5b9ae43c86ddad3048259c0f

[nomachine]

The same goal, only simplified.

simplified..but you're pulling hashes from all over. this seems like it will take forever to find a match. even with impressive speed. and the peed may be that impressive because its not generating the correct hash values, they dont match the private keys. 0000000000000000000000000000000000000000000000c856c4ca3cb9c8766e
Iteration 133394: Generated hash 04133ae3a72b383457c8116a13a8f6fe12236ced
Private Key Hex: 0000000000000000000000000000000000000000000000c85509b05931fa7e0f
Iteration 133395: Generated hash 5503e52f2f7b052b7f0d06680931e1e5f7dc72bf
Private Key Hex: 0000000000000000000000000000000000000000000000c5783688057c9ff90e
Iteration 133396: Generated hash dea497f05ab93a4cd82c04b7042e8909cb71ed86
Private Key Hex: 00000000000000000000000000000000000000000000002bfa3a7bcb95a6bda1
Iteration 133397: Generated hash 4924746a8c9c8d0de3598cecd6a12005579b4c75
Private Key Hex: 0000000000000000000000000000000000000000000000c8c0e47fd806b23588
Iteration 133398: Generated hash 31c10fc8c9584b7d454e191f7ba046f171ea5ebc
Private Key Hex: 00000000000000000000000000000000000000000000004d1d18f8ba61efb1c9
Iteration 133399: Generated hash b6c3e00fdc24f63f5b9ae43c86ddad3048259c0f

Code:

import os
import hashlib
import ecdsa
# List of target Hash 160 values to search for
target_public_key_hashes = [
    bytes.fromhex('20d45a6a762535700ce9e0b216e31994335db8a5'),
    bytes.fromhex('739437bb3dd6d1983e66629c5f08c70e52769371'),
    bytes.fromhex('e0b8a2baee1b77fc703455f39d51477451fc8cfc'),
    bytes.fromhex('61eb8a50c86b0584bb727dd65bed8d2400d6d5aa'),
    bytes.fromhex('f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8'),
]

min_range = 36893488147419103231 # Puzzle 66
max_range = 2361183241434822606847 # Puzzle 71

while True:
    random_bytes = os.urandom(9)
    initial_bytes = b'\x00' * 23
    full_bytes = initial_bytes + random_bytes
    dec = int.from_bytes(full_bytes, byteorder='big')

    if min_range <= dec <= max_range:
        signing_key = ecdsa.SigningKey.from_string(full_bytes, curve=ecdsa.SECP256k1)
        h160 = hashlib.new('ripemd160', hashlib.sha256(signing_key.get_verifying_key().to_string("compressed")).digest()).digest()
        if h160 in target_public_key_hashes:
            print(f"Found match with hash {h160.hex()}. Decoded value: {dec}")
            target_public_key_hashes.remove(h160)  # Remove the found hash from the list
            if not target_public_key_hashes:
                print("All target hashes found.")
                break

You can filter full_bytes based on a decimal range, a condition to check if the decimal value falls within the specified range. Three more lines of code.  

p.s.
Do not worry. This will last forever (on home computers) no matter what we invent.  

[Woz2000]

Exactly, this is what I am questioning. According to him, his i9 is getting 4Gkeys brute forcing without pub key....

He said it was from keyhunt, so unless he modified it, its straight brute force as pub key is not available for 66.

You're right. I can achieve a maximum of ~1 Ekeys/s with AMD Ryzen 9 7950X3D, but if I know what public key is.

...deleted...

If I don't know what public key is, the speed cannot be higher than 50 MKey/s. . .

Theoretically it could get closer... If you have a 128 Core
https://www.titancomputers.com/Titan-A475-Dual-AMD-EPYC-Milan-7003-Series-Proce-p/a475.htm

[digaran]

I think your comments/scripts confuse people more than helps them, IMO.

I thought everyone is a cryptography expert around here, or worked for more than 25 years on EC, if my methods confuses you is because you don't try working only with scalars to penetrate N the group order. If I explain everything step by step, where would be the fun in that? Have you shared anything you could discover by operating over scalars?
Whatever method, equation you can use to get definitive results over scalars, applies to points as well. I have explained how to get meaningful results based on that before. To Alek on a few previous pages, regarding how to get target /1024 for sure.
@mcdouglasx, sorry to hear that, I hope it all goes well God willing. Take care.🤲

[nomachine]

worked for more than 25 years on EC

To better understand the claim and specific experience with elliptic curves, we can ask you about your work, projects, and expertise in this area. This will provide more context and clarity about the 25 years you are referring to.

Can you point us to your published studies? I'm really curious and looking forward reading them.

We are still waiting for your reply from the other day. 

[WanderingPhilospher]

I think your comments/scripts confuse people more than helps them, IMO.

I thought everyone is a cryptography expert around here, or worked for more than 25 years on EC, if my methods confuses you is because you don't try working only with scalars to penetrate N the group order. If I explain everything step by step, where would be the fun in that? Have you shared anything you could discover by operating over scalars?
Whatever method, equation you can use to get definitive results over scalars, applies to points as well. I have explained how to get meaningful results based on that before. To Alek on a few previous pages, regarding how to get target /1024 for sure.
@mcdouglasx, sorry to hear that, I hope it all goes well God willing. Take care.🤲

Lol, I am not claiming I have discovered anything that isn't already talked about / known on this forum. However, I have not seen anything that you have given, with example, as something new.

One can sit back and sub, add, div, mult, all kind of pubs together, separately, by 100, by 1024, etc. and get a lot of different looking pubs, but it does not show how one is closer to showing a relation or reducing any keys, with 100%.

What meaningful results, with a concrete example, have you given? Not just asking us, "do you see that". Link to a concrete example of anything you have worked out in regards to these puzzles or EC for that matter. Thanks.

[WanderingPhilospher]

Code:

import subprocess
import time
import os
from decimal import Decimal
import base58
import hashlib
import ecdsa

# Function to clear the terminal screen
def clear_terminal():
    subprocess.call('clear', shell=True)

# Function to calculate the Hash 160 of a public key
def calculate_public_key_hash(public_key):
    sha256_hash = hashlib.sha256(public_key).digest()
    ripemd160_hash = hashlib.new('ripemd160')
    ripemd160_hash.update(sha256_hash)
    return ripemd160_hash.digest()

# Function to convert a decimal number to a private key in hexadecimal format
def decimal_to_private_key_hex(decimal_number):
    private_key_bytes = int(decimal_number).to_bytes(32, byteorder='big')
    private_key_hex = private_key_bytes.hex()
    private_key_hex_flipped = private_key_hex.replace('2', '3', 2)
    return private_key_hex, private_key_hex_flipped

# Function to check if a target Hash 160 is found
def check_target_hash(public_key_hash, decimal_number, private_key_hex):
    if public_key_hash in target_public_key_hashes:
        target_hashes_found.append(public_key_hash)
        print(f"Target Hash 160 found: {public_key_hash.hex()}")
        print(f"Decimal Number: {decimal_number}")
        print(f"Private Key Hex: {private_key_hex}")

        # Write the found Hash 160 to the file found_addresses.txt
        with open("found_addresses.txt", "a") as found_file:
            found_file.write(f"Target Hash 160 found: {public_key_hash.hex()}\n")
            found_file.write(f"Decimal Number: {decimal_number}\n")
            found_file.write(f"Private Key Hex: {private_key_hex}\n\n")
            found_file.flush()  # Flush the buffer to ensure data is written immediately

        return True
    return False

# List of target Hash 160 values to search for
target_public_key_hashes = [
    bytes.fromhex('20d45a6a762535700ce9e0b216e31994335db8a5'),
    bytes.fromhex('739437bb3dd6d1983e66629c5f08c70e52769371'),
    bytes.fromhex('e0b8a2baee1b77fc703455f39d51477451fc8cfc'),
    bytes.fromhex('61eb8a50c86b0584bb727dd65bed8d2400d6d5aa'),
    bytes.fromhex('f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8'),


]

target_hashes_found = []

# Define the lower and upper bounds for the decimal number search range
lower_bound = Decimal('37000000000000000000')
upper_bound = Decimal('55340232221128654832')

# List of additional hex numbers to modify the decimal number
additional_hex_numbers = ['3','4','5','6','7','8', '9', 'a', 'b', 'c', 'd', 'e', 'f','10','11','12','13','14','15','16','17','18','19','1a', '1b', '1c','1d', '1e', '1f'
,'40','41','42','43','44','45','46','47','48','49','4a', '4b', '4c','4d', '4e', '4f' ,'50','51','52','53','54','55','56','57','58','59','5a', '5b', '5c','5d', '5e', '5f' ,'60','61','62','63','64','65','66','67','68','69','6a', '6b', '6c','6d', '6e', '6f' ,'70','71','72','73','74','75','76','77','78','79','7a', '7b', '7c','7d', '7e', '7f' ]

# Initialize time and iteration tracking variables
start_time = time.time()
total_iterations = 0

# Function to search for target Hash 160 values within a specified range
def search_decimal_range(decimal_number, upper_bound):
    global total_iterations  # Use the global variable
    iterations = 0
    update_interval = 1
    step_size = 10000000000000000  # Initial step size

    while decimal_number <= upper_bound:
        private_key_hex, flipped_private_key_hex = decimal_to_private_key_hex(decimal_number)
        private_key = int(decimal_number).to_bytes(32, byteorder='big')
        signing_key = ecdsa.SigningKey.from_string(private_key, curve=ecdsa.SECP256k1, hashfunc=hashlib.sha256)
        verifying_key = signing_key.verifying_key
        public_key = verifying_key.to_string("compressed")
        public_key_hash = calculate_public_key_hash(public_key)

        if check_target_hash(public_key_hash, decimal_number, private_key_hex):
            return True  # Stop the loop if a match is found

        found_match = False

        additional_hashes = []
        for hex_number in additional_hex_numbers:
            modified_decimal_number = int(hex(int(decimal_number))[2:].replace('2', hex_number, 1), 16)
            modified_private_key_hex, _ = decimal_to_private_key_hex(modified_decimal_number)
            modified_private_key = int(modified_decimal_number).to_bytes(32, byteorder='big')
            modified_signing_key = ecdsa.SigningKey.from_string(modified_private_key, curve=ecdsa.SECP256k1, hashfunc=hashlib.sha256)
            modified_verifying_key = modified_signing_key.verifying_key
            modified_public_key = modified_verifying_key.to_string("compressed")
            modified_hash = calculate_public_key_hash(modified_public_key)
            additional_hashes.append(modified_hash)

            if check_target_hash(modified_hash, modified_decimal_number, modified_private_key_hex):
                found_match = True
                break

        if found_match:
            return True

        if len(target_hashes_found) == len(target_public_key_hashes):
            return True

        if iterations % update_interval == 0:
            elapsed_time = time.time() - start_time
            iterations_per_second = iterations / elapsed_time
            print(f"Reached {iterations} iterations.")
            print(f"Elapsed Time: {elapsed_time:.2f} seconds")
            print(f"Iterations per Second: {iterations_per_second:.2f}")
            print(f"Decimal Number: {decimal_number}")
            print(f"Private Key Hex: {private_key_hex}")
            print(f"Target Hash 160: {public_key_hash.hex()}")
            print(f"Target Decimal Number: {decimal_number}")
            if target_hashes_found:
                print_hashes_side_by_side(target_hashes_found[-1], decimal_number, private_key_hex, additional_hashes)
            print("\n")

        decimal_number += step_size  # Increase the decimal number by the current step size
        iterations += 1

        # Adjust the step size dynamically based on the search space
        if iterations % 1000 == 0:
            step_size *= 2  # Double the step size every 1 million iterations

# Function to print the target Hash 160 and additional Hash 160 values side by side
def print_hashes_side_by_side(target_hash, decimal_number, private_key_hex, additional_hashes):
    print(f"Decimal Number: {decimal_number}")
    print(f"Target Hash 160: {target_hash.hex()}")
    print(f"Private Key Hex: {private_key_hex}")
    print(f"Target Decimal Number: {decimal_number}")
    for i, hash in enumerate(additional_hashes):
        print(f" ({additional_hex_numbers[i]}): {hash.hex()}")
    print("\n")

# Function to continuously search for target Hash 160 values in the specified range
def continuous_search(lower_bound, upper_bound):
    global total_iterations, start_time  # Use the global variables
    current_decimal = lower_bound

    while True:
        elapsed_time = time.time() - start_time
        total_iterations += 1

        if search_decimal_range(current_decimal, upper_bound):
            print("All target Hash 160 values found. Restarting search...")
            time.sleep(0)  # Optional: Add a delay before restarting the search
            current_decimal = lower_bound  # Reset the current_decimal to the lower_bound
        else:
            current_decimal += 1484585542367  # Increment by 1

# Start the continuous search
while True:
    continuous_search(lower_bound, upper_bound)

# Add sound notification when the script completes
print("Glass sound (indicating script completion)")
subprocess.run(["afplay", "/System/Library/Sounds/glass.aiff"])

hows this one? ready for some fun?   THIS ONE SCRIPT IS SEARCHING FOR PUZZLES 66 -71 from a single hex which is 20000000000000000...2ffffffffffffffff. I can also adjust the step size.

MoreForUs, what speed are you showing with your program? When I ran it a few times, it seems very slow, and the text is somewhat confusing.
What is considered an iteration, one key checked?
Also:

Code:

Reached 12 iterations.
Elapsed Time: 0.53 seconds
Iterations per Second: 22.43
Decimal Number: 37120000000000000000
Private Key Hex: 0000000000000000000000000000000000000000000000020324bb546e800000
Target Hash 160: 09d19b3025828bca263e80cf2b5da1e08e938ca3
Target Decimal Number: 37120000000000000000

Reached 170 iterations.
Elapsed Time: 14.13 seconds
Iterations per Second: 12.03
Decimal Number: 38700000000000000000
Private Key Hex: 000000000000000000000000000000000000000000000002191204f5679e0000
Target Hash 160: 846874d169173600744fe5c1cdf9f2915cdb25ae
Target Decimal Number: 38700000000000000000

The Target Hash 160 verbiage is misleading, as it's not the target 160, it's the actual 160 of the current Private Key Hex being checked. Same for Target Dec Num, if we knew the target, we wouldn't be talking lol.

Anywho, I am trying to compare it's speed to my old slow python script; I think mine checks 3,000 key/s on a single core.

[MoreForUs]

MoreForUs, what speed are you showing with your program? When I ran it a few times, it seems very slow, and the text is somewhat confusing.
What is considered an iteration, one key checked?
Also:

Code:

Reached 12 iterations.
Elapsed Time: 0.53 seconds
Iterations per Second: 22.43
Decimal Number: 37120000000000000000
Private Key Hex: 0000000000000000000000000000000000000000000000020324bb546e800000
Target Hash 160: 09d19b3025828bca263e80cf2b5da1e08e938ca3
Target Decimal Number: 37120000000000000000

Reached 170 iterations.
Elapsed Time: 14.13 seconds
Iterations per Second: 12.03
Decimal Number: 38700000000000000000
Private Key Hex: 000000000000000000000000000000000000000000000002191204f5679e0000
Target Hash 160: 846874d169173600744fe5c1cdf9f2915cdb25ae
Target Decimal Number: 38700000000000000000

The Target Hash 160 verbiage is misleading, as it's not the target 160, it's the actual 160 of the current Private Key Hex being checked. Same for Target Dec Num, if we knew the target, we wouldn't be talking lol.

Anywho, I am trying to compare it's speed to my old slow python script; I think mine checks 3,000 key/s on a single core.

I am getting about 300 keys per second, currently looking into speeding it up. 1 way would be to reduce all of the additional hex keys i am searching for.
additional_hex_numbers = ['3','4','5','6','7','8', '9', 'a', 'b', 'c', 'd', 'e', 'f','10','11','12','13','14','15','16','17','18','19','1a', '1b', '1c','1d', '1e', '1f'
,'40','41','42','43','44','45','46','47','48','49','4a', '4b', '4c','4d', '4e', '4f' ,'50','51','52','53','54','55','56','57','58','59','5a', '5b', '5c','5d', '5e', '5f' ,'60','61','62','63','64','65','66','67','68','69','6a', '6b', '6c','6d', '6e', '6f' ,'70','71','72','73','74','75','76','77','78','79','7a', '7b', '7c','7d', '7e', '7f' ] its also written like that, so when a match is found it will print verbatim.

[WanderingPhilospher]

I am getting about 300 keys per second, currently looking into speeding it up. 1 way would be to reduce all of the additional hex keys i am searching for.
additional_hex_numbers = ['3','4','5','6','7','8', '9', 'a', 'b', 'c', 'd', 'e', 'f','10','11','12','13','14','15','16','17','18','19','1a', '1b', '1c','1d', '1e', '1f'
,'40','41','42','43','44','45','46','47','48','49','4a', '4b', '4c','4d', '4e', '4f' ,'50','51','52','53','54','55','56','57','58','59','5a', '5b', '5c','5d', '5e', '5f' ,'60','61','62','63','64','65','66','67','68','69','6a', '6b', '6c','6d', '6e', '6f' ,'70','71','72','73','74','75','76','77','78','79','7a', '7b', '7c','7d', '7e', '7f' ] its also written like that, so when a match is found it will print verbatim

Mine does the same as yours. But I only have it programmed up to #69.
But I do not have all the additional hex numbers; I merely use a stride of
0x1000000000000000
So it generates a random number in the 2000…(66 bit) range, then iterates up to
7f000…(69 bit) and then I hit it with an if statement, that if it goes over 0x8000…to generate a new random starting point in the 0x2000…(66 bit) range and then rinse and repeat until key is found.

I am sure there are several ways to speed my old script up as well.

EDIT: I also use a file with the targets in it and use the Python set feature.

[WanderingPhilospher]

MoreForUs, here is my similar script. I wrote this probably 3 years ago when everyone was looking for #64, in old Python 2.7

Code:

import binascii, hashlib, base58, sys, ecdsa, codecs, random
pkeys = set(line.rstrip() for line in open('H160Targets.txt'))

lr    = 0x20000000000000000
ur    = 0x21000000000000000
br    = random.randrange(lr, ur)

def com(privkey):
   
    pvk_to_bytes = codecs.decode (privkey, 'hex')
    key = ecdsa.SigningKey.from_string (pvk_to_bytes, curve=ecdsa.SECP256k1).verifying_key
    key_bytes = key.to_string()
    key_hex = codecs.encode(key_bytes, 'hex')
   
    if(ord(bytearray.fromhex(key_hex[-2:])) % 2 == 0):
        public_key_compressed = '02' + key_hex[0:64]
        public_key_in_bytes = codecs.decode(public_key_compressed, 'hex')
        sha256_public_key_compressed = hashlib.sha256(public_key_in_bytes)
        sha256_public_key_compressed_digest = sha256_public_key_compressed.digest()
        ripemd160 = hashlib.new('ripemd160')
        ripemd160.update(sha256_public_key_compressed_digest)
        ripemd160_digest = ripemd160.digest()
        ripemd160_hex = codecs.encode(ripemd160_digest, 'hex')
        if ripemd160_hex in pkeys:
            fwrite = open('KeyFound.txt', 'a')
            fwrite.write('Key: ' + privk + '  ' + ripemd160_hex + '\n' )
           
    else:
        public_key_compressed = '03' + key_hex[0:64]
        public_key_in_bytes = codecs.decode(public_key_compressed, 'hex')
        sha256_public_key_compressed = hashlib.sha256(public_key_in_bytes)
        sha256_public_key_compressed_digest = sha256_public_key_compressed.digest()
        ripemd160 = hashlib.new('ripemd160')
        ripemd160.update(sha256_public_key_compressed_digest)
        ripemd160_digest = ripemd160.digest()
        ripemd160_hex = codecs.encode(ripemd160_digest, 'hex')
        if ripemd160_hex in pkeys:
            fwrite = open('KeyFound.txt', 'a')
            fwrite.write('Key: ' + privk + '  ' + ripemd160_hex + '\n' )

countall = 0
while True:

    if __name__== "__main__":

        privk = hex( br ).lstrip("0x").rstrip("L").zfill(64)
        com(privk)
        br = (br + 0x1000000000000000)
        sys.stdout.write("\r" + "   # of Keys: "  + str(countall))
        sys.stdout.flush()
        countall +=1
        if (br > 0x200000000000000000):
            lr    = 0x20000000000000000
            ur    = 0x21000000000000000
            br    = random.randrange(lr, ur)

As stated, I use a .txt file to store the h160 targets in and use the set function.

[digaran]

Code:

499218910101699464426468676555989843968 /
 3808738022626491275226354038665694 =  131072

Code:

Target_1 =  0x0000000000000000000000000000000377921095386a9e4adb9c7eb1e3bda61c
Target_2 is known =  0x000000000000000000000000000000020000000000000000000000000000a61c
Both targets/131072, subtracting division results
Offset_1 = 0x000000000000000000000000000000000000bbc9084a9c354f256dce3f58f1de

Now replace target_2 with whatever you want, divide with whatever you like, then subtract and add the results, DO NOT try this with public keys, waste of time.

[WanderingPhilospher]

Code:

499218910101699464426468676555989843968 /
 3808738022626491275226354038665694 =  131072

Code:

Target_1 =  0x0000000000000000000000000000000377921095386a9e4adb9c7eb1e3bda61c
Target_2 is known =  0x000000000000000000000000000000020000000000000000000000000000a61c
Both targets/131072, subtracting division results
Offset_1 = 0x000000000000000000000000000000000000bbc9084a9c354f256dce3f58f1de

Now replace target_2 with whatever you want, divide with whatever you like, then subtract and add the results, DO NOT try this with public keys, waste of time.

All I can see is that you ended up getting a BBC 👀

[nomachine]

reduce all of the additional hex keys i am searching for.

Code:

import os, random, secrets, hashlib, ecdsa

# List of target Hash 160 values to search for
target_public_key_hashes = [
    bytes.fromhex('20d45a6a762535700ce9e0b216e31994335db8a5'),
    bytes.fromhex('739437bb3dd6d1983e66629c5f08c70e52769371'),
    bytes.fromhex('e0b8a2baee1b77fc703455f39d51477451fc8cfc'),
    bytes.fromhex('61eb8a50c86b0584bb727dd65bed8d2400d6d5aa'),
    bytes.fromhex('f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8'),
]
# Open a file for writing the found matches
with open('found_matches.txt', 'w') as output_file:
    while True:
        dec = secrets.SystemRandom().randrange(36893488147419103231, 2361183241434822606847)
        private_key_bytes = (b'\x00' * 32)[:-len(dec.to_bytes((dec.bit_length() + 7) // 8, 'big'))] + dec.to_bytes((dec.bit_length() + 7) // 8, 'big')
        signing_key = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
        h160 = hashlib.new('ripemd160', hashlib.sha256(signing_key.get_verifying_key().to_string("compressed")).digest()).digest()
        h160_hex = h160.hex()       
        if h160_hex.startswith(('20d45a', '739437', 'e0b8a2', '61eb8a', 'f6f543')):
            print(h160_hex, dec)
            if h160 in target_public_key_hashes:
                match_str = f"Found match with hash {dec}\n"
                print(match_str)
                output_file.write(match_str)
                target_public_key_hashes.remove(h160)  # Remove the found hash from the list
                if not target_public_key_hashes:
                    print("All target hashes found.")
                    break

There is no limit and way someone can search for a puzzle. It's like art. Mostly worthless art collection. 

[digaran]

Code:

499218910101699464426468676555989843968 /
 3808738022626491275226354038665694 =  131072

Code:

Target_1 =  0x0000000000000000000000000000000377921095386a9e4adb9c7eb1e3bda61c
Target_2 is known =  0x000000000000000000000000000000020000000000000000000000000000a61c
Both targets/131072, subtracting division results
Offset_1 = 0x000000000000000000000000000000000000bbc9084a9c354f256dce3f58f1de

Now replace target_2 with whatever you want, divide with whatever you like, then subtract and add the results, DO NOT try this with public keys, waste of time.

All I can see is that you ended up getting a BBC 👀

That's because you are a pervert, I might add that I don't have the capacity for a big black... wait are we talking about the same thing? Lol  Well that BBC is your answer, but it seems nobody has figured it out yet. Good news for our dragon.😉

[Denis_Hitov]

subtract G 99 times from target, you will have 100 keys in total, then divide them all by 100, one of the results will definitely be the target/100. Then come here ask me what's next. But first I would need to test your script to see if it does what I said.😉

Hello, is this what you need?

Code:

import secp256k1 as ice
import bitcoin

target= "03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852"
print("Target:", target)
Target_upub= ice.pub2upub(target)

for i in range (100):
    A= ice.scalar_multiplication(i)
    B= ice.point_subtraction(Target_upub, A)
    C= ice.to_cpub(B.hex())
    D= bitcoin.divide(C, 100)

    data = open("S-1.txt","a")
    data.write(str(i)+" = "+str(C)+"\n")
    data.close()

    data = open("D-1.txt","a")
    data.write(str(i)+" = "+str(D)+"\n")
    data.close()

Hello.
Tell me how to remove this error?
PermissionError: [Errno 13] Permission denied:

No matter what I tried, it didn't work...

Code:

C:\BTCPazzle>test.py
Target: 0230210c23b1a047bc9bdbb13448e67deddc108946de6de639bcc75d47c0216b1b
Traceback (most recent call last):
  File "C:\BTCPazzle>test.py", line 20, in <module>
    data = open("D-1000.txt","a")
PermissionError: [Errno 13] Permission denied: "D-1000.txt"

[digaran]

Hello.
Tell me how to remove this error?
PermissionError: [Errno 13] Permission denied:

No matter what I tried, it didn't work...

Code:

C:\BTCPazzle>test.py
Target: 0230210c23b1a047bc9bdbb13448e67deddc108946de6de639bcc75d47c0216b1b
Traceback (most recent call last):
  File "C:\BTCPazzle>test.py", line 20, in <module>
    data = open("D-1000.txt","a")
PermissionError: [Errno 13] Permission denied: "D-1000.txt"

What did you try? Did you try running as administrator? Sometimes I used to get that error, I don't know the exact reason, because it wasn't always happening. It just returns that error because your system doesn't allow the script to open the text file, maybe change your directory?  Try like this if you are using windows, type in search box inside BTCPazzle folder, type cmd and hit enter, then type python test.py hit enter, this should fix it.