Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 148. (Read 230098 times)

import re

# Function to process the text and extract the desired parts
def extract_text(input_file, output_file):
    with open(input_file, 'r') as f:
        input_text = f.read()

    # Regular expression pattern to capture the desired text
    pattern = r'(\b\w+_\w+\b)\s*\|\s*(\b\w+_\w+\b)\s*\|\s*\w+\s*\|\s*(\b\w+_\w+\b)\s*\|'

    matches = re.findall(pattern, input_text)

    # Create the new text format from the extracted matches
    output_text = "\n".join([" | ".join(match) for match in matches])

    # Write the new text to the output file
    with open(output_file, 'w') as f:
        f.write(output_text)

# Example usage
input_file = '1.txt'
output_file = '2.txt'
extract_text(input_file, output_file)

cat 1.txt | cut -d '|' -f1,2,4 > 2.txt

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

    With open("D-1.txt","a") as file:
    file.write(str(i)+" = "+str(D)+"\n")
    file.close()

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

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

499218910101699464426468676555989843968 /
 3808738022626491275226354038665694 =  131072

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

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)