Bitcoin puzzle transaction ~32 BTC prize to who solves it

[saeedxxx]

They probably don't know how to Export the Raw Transaction from Electrum and copy/paste it to Mara slipstream window.
But anyway, if someone wants to pay for copy/paste 10%, I'm here.  

No, I mean if he could transfer puzzle #66 to his own wallet using RBF, bsgs method …
Would he return 90% of the reward to the real finder? (The one who proves ownership by sharing sha256 of publickey or privatekey before broadcasting the first transaction)

[nomachine]

transfer puzzle #66 to his own wallet using RBF

Anyone who tries RBF through mempool will be left with 0 BTC. Because the bot will find the private key in 10 seconds.
In fact, any public transaction with puzzle 66 is disastrous. The outcome is uncertain.

[gygy]

They probably don't know how to Export the Raw Transaction from Electrum and copy/paste it to Mara slipstream window.
But anyway, if someone wants to pay for copy/paste 10%, I'm here.  

Maybe he tries to sell the key with a discount. That is a different situation, it is not just help to copy-paste. It is about the risk of failure.

[Cricktor]

How can it be any safe for a buyer of any unkown puzzle's private key? Let's stick to #66 as of now. A potential seller can prove that he actually found the correct private key by disclosing SHA256(public key). Some large mining pool operators would be excellent buyers as they have sufficient hashing power at their "disposal" and could confirm spending the #66's coins without making the transaction public. Keeping the spending transaction secret is crucial, no way around it so far.

But it's still a risky deal for any buyer as any second someone else could've found the damn private key! Back to square one with potential of high loss. Selling the private key for some (substantial?) discount is likely worse than a half backed solution.

[garlonicon]

But it's still a risky deal for any buyer as any second someone else could've found the damn private key!

Then, it is "mining pool vs mining pool". Reorging a single block is not that easy. First, the block will quickly propagate across the whole network, so a lot of major pools will be mining on top of the earliest one. And second: successfully mining a single block is not enough to reorg the chain. You would need to mine two blocks: one on the same height, and another one, on top of it, to actually trigger a chain reorganization.

Also, it is possible to check on testnet, how hard it is to reorg a single confirmation (especially, if a block is ASIC-confirmed). Sending 9950 tBTC in fees was not reverted, even though the block was CPU-mined. I don't know exactly, which amount would be big enough, to get it reorged, but I am accumulating test coins, to test that kind of scenarios.

Edit: More than that: small pools have too low hashrate, to succeed at such attack. And big mining pools have too much reputation to lose, because if some pool will attack, then by looking at chaintips, node runners could prove, that "the pool named X stole those coins". And then, you can imagine, how many miners will switch to a different pool in that case.

So, full-RBF is applied only to transactions, not to the whole blocks. In case of blocks, it is first-seen. And you need two blocks, to trigger a reorg, a single block is not enough, because first-seen block will be different in 99% of mining pools, so they will extend the original chain.

[mcdouglasx]

Prove that you have the 66 private key by sharing the SHA-256 of the public key. This way we can verify if the address is correct

No one will be able to derive the public key, but we can verify that you have it

I suppose you mean sharing the double Sha256 hash, I don't know how sure it would be against brute force, when giving the hash256 of the public key directly by mistake.

[MisterZz]

To prove that key has been found, an easy and reliable way to confirm this could be for the finder to make a transaction to the respective pk ETH address and then make a withdrawal. This way I believe I think doesn’t compromise key in any way. At this point I would start to take all this seriously.

Edit_
After some research… Is there a way to check equivalent BTC-ETH address without any privkey risk?

[albert0bsd]

After some research… Is there a way to check equivalent BTC-ETH address without any privkey risk?

No there is no way, Eth address are a partial hash keccak of the public key.

A lot of people already said that sharing the hash sha256 of the public is a secure way to prove tha you know the private key, and that is correct.

double Sha256 hash, I don't know how sure it would be against brute force, when giving the hash256 of the public key directly by mistake.

It is a single hash.

Bitcoin use a double hash to generare the address (sha256 - rmd160) that is the so called double hash.

With only the sha256 hash we has half of the way to the address without compromise the public key.

[Mr.right85]

They probably don't know how to Export the Raw Transaction from Electrum and copy/paste it to Mara slipstream window.
But anyway, if someone wants to pay for copy/paste 10%, I'm here.  

Maybe he tries to sell the key with a discount. That is a different situation, it is not just help to copy-paste. It is about the risk of failure.

Do anyone really win in these puzzles?
I don’t follow up on these puzzles because, it’s always a hard to agree if someone would sell a wallet that is worth so much for less. Maybe am missing something here but, what stops the individual from trying to do it themselves and own whatever is on it. Except there is nothing on it which wouldn’t surprise me very much or perhaps, you never get to solve the puzzle. Are there people to have solved a few of these here?

[albert0bsd]

Do anyone really win in these puzzles?

Yes some users found some of them and documented it here.

Some puzzles were solved and NOT documented because: privacy and anonymity just to avoid being spammed by assholes and opportunists.

imagine your self telling the world that you found some 6 or 12 bitcoins, there are people that kill for less of that.

If someone found a puzzle he/they never would sell it, anyone selling wallets instead redeem them it self is a scammer.

[abdenn0ur]

Trust me

Crypto users don't trust, they verify, so unless you provide a way to support your claims, your post means absolutely nothing.

[AliBah]

is there anyway to use Keyhunt for wallets that starts with 3 and bc ?

[albert0bsd]

is there anyway to use Keyhunt for wallets that starts with 3 and bc ?

Please for keyhunt doubts use the topic of keyhunt that I open in this forum: https://bitcointalk.org/index.php?topic=5322040.0

The answer is No, there is no way to use it against address with 3 or bc1

[AliBah]

is there anyway to use Keyhunt for wallets that starts with 3 and bc ?

Please for keyhunt doubts use the topic of keyhunt that I open in this forum: https://bitcointalk.org/index.php?topic=5322040.0

The answer is No, there is no way to use it against address with 3 or bc1

ok sure, thank you

[VinIVaderr]

This code will generate a random string.
Then it will adjust each column range(1, 16)
If column 1 is 0x2 then the next string is 0x3, 0x4, 0x5 - 0x1
It will do this for each column.

Code:

from bitcoin import privtopub, pubtoaddr
import random
import string
import multiprocessing
import time
import os
import secrets
def create_random_slider_field(columns):
    return [random.choice(string.hexdigits.lower()) for _ in range(columns)]

def adjust_slider(slider, column, direction):
    hex_chars = string.hexdigits.lower()
    current_index = hex_chars.index(slider[column])
    new_index = (current_index + direction) % len(hex_chars)
    slider[column] = hex_chars[new_index]
    return slider

def check_address(private_key, target_address):
    try:
        address = pubtoaddr(privtopub(private_key))
        return address == target_address
    except Exception as e:
        print(f"Error generating address: {e}")
        return False

def search_process(target_address, process_attempts, result_queue):	
    byte_values = list(range(256))
    random_bytes = [secrets.choice(byte_values) for _ in range(8)]
    random.seed(int.from_bytes(random_bytes))
	
    slider_columns = 19  
    attempts = 0
    hex_chars = string.hexdigits.lower()

    while attempts < process_attempts:
        slider = create_random_slider_field(slider_columns)
        
        for column in range(slider_columns):
            original_value = slider[column]
            original_index = hex_chars.index(original_value)
            
            # Check original value
            private_key = '0' * 46 + '1' + ''.join(slider)     # Updated prefix, adjust leading zeros.
            if check_address(private_key, target_address):
                result_queue.put((private_key, attempts))
                return
            attempts += 1

            # Optimized range checking
            for i in range(1, 16):
                # Check increasing values
                new_index = (original_index + i) % 16
                slider[column] = hex_chars[new_index]
                private_key = '0' * 46 + '1' + ''.join(slider)   # Updated prefix, adjust leading zeros.
                if check_address(private_key, target_address):
                    result_queue.put((private_key, attempts))
                    return
                attempts += 1
	  
			   # Reset to original value before moving to next column
            slider[column] = original_value

        if attempts % 1000 == 0:
            print(f"Process {multiprocessing.current_process().name} Attempts: {attempts}, Current slider: {''.join(slider)}")

    result_queue.put((None, attempts))

def multiprocessing_search(target_address, max_attempts=1000000, num_processes=4):   #max_attempts / 4 cores
    processes = []
    result_queue = multiprocessing.Queue()
    attempts_per_process = max_attempts // num_processes

    start_time = time.time()

    for i in range(num_processes):
        p = multiprocessing.Process(
            target=search_process,
            args=(target_address, attempts_per_process, result_queue)
        )
        processes.append(p)
        p.start()

    total_attempts = 0
    for _ in range(num_processes):
        result, attempts = result_queue.get()
        total_attempts += attempts
        if result:
            # Stop all processes
            for p in processes:
                p.terminate()
            return result, total_attempts

    # Wait for all processes to complete
    for p in processes:
        p.join()

    end_time = time.time()
    print(f"Total time: {end_time - start_time:.2f} seconds")
    return None, total_attempts

# Main program
if __name__ == "__main__":
    target_address = "19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG"    #  puzzle address
    print(f"Target Bitcoin Address: {target_address}")

    result, attempts = multiprocessing_search(target_address)

    if result:
        f = open("keys.txt", "a")
        f.write(result + '\n')
        f.close()
        print(f"Matching private key found: {result}")
        print(f"Total attempts: {attempts}")
        f = open("keys.txt", "a")
        f.write(result + '\n')
        f.close()
    else:
        print(f"No match found after {attempts} attempts")

[Akito S. M. Hosana]

This code will generate a random string.

Target Bitcoin Address: 19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG
Process Process-2:
Traceback (most recent call last):
  File "/usr/lib/python3.9/multiprocessing/process.py", line 315, in _bootstrap
    self.run()
  File "/usr/lib/python3.9/multiprocessing/process.py", line 108, in run
    self._target(*self._args, **self._kwargs)
  File "/kern/Desktop/test.py", line 29, in search_process
    random.seed(int.from_bytes(random_bytes))
TypeError: from_bytes() missing required argument 'byteorder' (pos 2)
Process Process-1:
Traceback (most recent call last):
  File "/usr/lib/python3.9/multiprocessing/process.py", line 315, in _bootstrap
    self.run()
  File "/usr/lib/python3.9/multiprocessing/process.py", line 108, in run
    self._target(*self._args, **self._kwargs)
  File "/kern/Desktop/test.py", line 29, in search_process
    random.seed(int.from_bytes(random_bytes))
TypeError: from_bytes() missing required argument 'byteorder' (pos 2)
Process Process-3:
Traceback (most recent call last):
  File "/usr/lib/python3.9/multiprocessing/process.py", line 315, in _bootstrap
    self.run()
  File "/usr/lib/python3.9/multiprocessing/process.py", line 108, in run
    self._target(*self._args, **self._kwargs)
  File "/kern/Desktop/test.py", line 29, in search_process
    random.seed(int.from_bytes(random_bytes))
TypeError: from_bytes() missing required argument 'byteorder' (pos 2)
Process Process-4:
Traceback (most recent call last):
  File "/usr/lib/python3.9/multiprocessing/process.py", line 315, in _bootstrap
    self.run()
  File "/usr/lib/python3.9/multiprocessing/process.py", line 108, in run
    self._target(*self._args, **self._kwargs)
  File "/kern/Desktop/test.py", line 29, in search_process
    random.seed(int.from_bytes(random_bytes))
TypeError: from_bytes() missing required argument 'byteorder' (pos 2)
^CTraceback (most recent call last):
  File "/kern/Desktop/test.py", line 106, in <module>
    result, attempts = multiprocessing_search(target_address)
  File "/kern/Desktop/test.py", line 85, in multiprocessing_search
    result, attempts = result_queue.get()
  File "/usr/lib/python3.9/multiprocessing/queues.py", line 103, in get
    res = self._recv_bytes()
  File "/usr/lib/python3.9/multiprocessing/connection.py", line 221, in recv_bytes
    buf = self._recv_bytes(maxlength)
  File "/usr/lib/python3.9/multiprocessing/connection.py", line 419, in _recv_bytes
    buf = self._recv(4)
  File "/usr/lib/python3.9/multiprocessing/connection.py", line 384, in _recv
    chunk = read(handle, remaining)

[VinIVaderr]

I am using linux python3.11.2 and it works just fine on my machine.
I was hoping someone could add to it or offer some suggestions.
I realize it is python code and very slow, impossible even but it does work.

[cnk1220]

This code will generate a random string.
Then it will adjust each column range(1, 16)
If column 1 is 0x2 then the next string is 0x3, 0x4, 0x5 - 0x1
It will do this for each column.

Code:

from bitcoin import privtopub, pubtoaddr
import random
import string
import multiprocessing
import time
import os
import secrets
def create_random_slider_field(columns):
    return [random.choice(string.hexdigits.lower()) for _ in range(columns)]

def adjust_slider(slider, column, direction):
    hex_chars = string.hexdigits.lower()
    current_index = hex_chars.index(slider[column])
    new_index = (current_index + direction) % len(hex_chars)
    slider[column] = hex_chars[new_index]
    return slider

def check_address(private_key, target_address):
    try:
        address = pubtoaddr(privtopub(private_key))
        return address == target_address
    except Exception as e:
        print(f"Error generating address: {e}")
        return False

def search_process(target_address, process_attempts, result_queue):	
    byte_values = list(range(256))
    random_bytes = [secrets.choice(byte_values) for _ in range(8)]
    random.seed(int.from_bytes(random_bytes))
	
    slider_columns = 19  
    attempts = 0
    hex_chars = string.hexdigits.lower()

    while attempts < process_attempts:
        slider = create_random_slider_field(slider_columns)
        
        for column in range(slider_columns):
            original_value = slider[column]
            original_index = hex_chars.index(original_value)
            
            # Check original value
            private_key = '0' * 46 + '1' + ''.join(slider)     # Updated prefix, adjust leading zeros.
            if check_address(private_key, target_address):
                result_queue.put((private_key, attempts))
                return
            attempts += 1

            # Optimized range checking
            for i in range(1, 16):
                # Check increasing values
                new_index = (original_index + i) % 16
                slider[column] = hex_chars[new_index]
                private_key = '0' * 46 + '1' + ''.join(slider)   # Updated prefix, adjust leading zeros.
                if check_address(private_key, target_address):
                    result_queue.put((private_key, attempts))
                    return
                attempts += 1
	  
			   # Reset to original value before moving to next column
            slider[column] = original_value

        if attempts % 1000 == 0:
            print(f"Process {multiprocessing.current_process().name} Attempts: {attempts}, Current slider: {''.join(slider)}")

    result_queue.put((None, attempts))

def multiprocessing_search(target_address, max_attempts=1000000, num_processes=4):   #max_attempts / 4 cores
    processes = []
    result_queue = multiprocessing.Queue()
    attempts_per_process = max_attempts // num_processes

    start_time = time.time()

    for i in range(num_processes):
        p = multiprocessing.Process(
            target=search_process,
            args=(target_address, attempts_per_process, result_queue)
        )
        processes.append(p)
        p.start()

    total_attempts = 0
    for _ in range(num_processes):
        result, attempts = result_queue.get()
        total_attempts += attempts
        if result:
            # Stop all processes
            for p in processes:
                p.terminate()
            return result, total_attempts

    # Wait for all processes to complete
    for p in processes:
        p.join()

    end_time = time.time()
    print(f"Total time: {end_time - start_time:.2f} seconds")
    return None, total_attempts

# Main program
if __name__ == "__main__":
    target_address = "19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG"    #  puzzle address
    print(f"Target Bitcoin Address: {target_address}")

    result, attempts = multiprocessing_search(target_address)

    if result:
        f = open("keys.txt", "a")
        f.write(result + '\n')
        f.close()
        print(f"Matching private key found: {result}")
        print(f"Total attempts: {attempts}")
        f = open("keys.txt", "a")
        f.write(result + '\n')
        f.close()
    else:
        print(f"No match found after {attempts} attempts")

Sorry, but did I lost something?
What is that about?

[unclevito]

If just for puzzle 69 try these adjustments

from bitcoin import privtopub, pubtoaddr
import random
import string
import multiprocessing
import time
import os
import secrets

def create_random_slider_field(columns):
    return [random.choice(string.hexdigits.lower()) for _ in range(columns)]

def adjust_slider(slider, column, direction):
    hex_chars = string.hexdigits.lower()
    current_index = hex_chars.index(slider[column])
    new_index = (current_index + direction) % len(hex_chars)
    slider[column] = hex_chars[new_index]
    return slider

def check_address(private_key, target_address):
    try:
        address = pubtoaddr(privtopub(private_key))
        return address == target_address
    except Exception as e:
        print(f"Error generating address: {e}")
        return False

def search_process(target_address, process_attempts, result_queue):
    byte_values = list(range(256))
    random_bytes = [secrets.choice(byte_values) for _ in range(8)]
    random.seed(int.from_bytes(random_bytes, byteorder='big'))

    slider_columns = 17  # Adjusted to 17 for remaining digits
    attempts = 0
    hex_chars = string.hexdigits.lower()

    while attempts < process_attempts:
        slider = create_random_slider_field(slider_columns)

        # Construct private key with fixed '1' at the start
        private_key = '0' * 46 + '1' + ''.join(slider)

        # Check the constructed private key
        if check_address(private_key, target_address):
            result_queue.put((private_key, attempts))
            return
        attempts += 1

        if attempts % 1000 == 0:
            print(f"Process {multiprocessing.current_process().name} Attempts: {attempts}, Current slider: 1{''.join(slider)}")

    result_queue.put((None, attempts))

def multiprocessing_search(target_address, max_attempts=1000000, num_processes=4):   #max_attempts / 4 cores
    processes = []
    result_queue = multiprocessing.Queue()
    attempts_per_process = max_attempts // num_processes

    start_time = time.time()

    for i in range(num_processes):
        p = multiprocessing.Process(
            target=search_process,
            args=(target_address, attempts_per_process, result_queue)
        )
        processes.append(p)
        p.start()

    total_attempts = 0
    for _ in range(num_processes):
        result, attempts = result_queue.get()
        total_attempts += attempts
        if result:
            # Stop all processes
            for p in processes:
                p.terminate()
            return result, total_attempts

    # Wait for all processes to complete
    for p in processes:
        p.join()

    end_time = time.time()
    print(f"Total time: {end_time - start_time:.2f} seconds")
    return None, total_attempts

if __name__ == "__main__":
    target_address = "19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG"    #  puzzle address
    print(f"Target Bitcoin Address: {target_address}")

    result, attempts = multiprocessing_search(target_address)

    if result:
        f = open("keys.txt", "a")
        f.write(result + '\n')
        f.close()
        print(f"Matching private key found: {result}")
        print(f"Total attempts: {attempts}")
        f = open("keys.txt", "a")
        f.write(result + '\n')
        f.close()
    else:
        print(f"No match found after {attempts} attempts")

[digitalbear]

This code ^^^ is working for me: https://prnt.sc/AZN7Pvw8fbQS
But is just slow, I have about 3-5keys keys/s since is using only CPU, is better to use vanityseach with random mode Vbcr.exe where I have like 200-300Million keys/s using GPU