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

import requests

def get_mempool_data():
    try:
        response = requests.get('https://mempool.space/api/v1/fees/recommended')
        response.raise_for_status()  # Raises HTTPError for bad responses (4xx and 5xx)
        return response.json()
    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err}")  # HTTP error
    except requests.exceptions.RequestException as req_err:
        print(f"Request error occurred: {req_err}")  # Other request errors
    except ValueError as json_err:
        print(f"JSON decode error: {json_err}")  # JSON decode error
    return None

def get_feerates(mempool_data):
    next_block_feerate = mempool_data['fastestFee']
    bottom_mempool_feerate = mempool_data['minimumFee']
    return next_block_feerate, bottom_mempool_feerate

def calculate_replacement_strategy(transactions, next_block_feerate, bottom_mempool_feerate):
    def get_mineable_feerate(transaction, ancestors_fee, ancestors_size):
        return (ancestors_fee + transaction['fee']) / (ancestors_size + transaction['size'])

    results = []
    for tx_name, tx in transactions.items():
        ancestors_fee = sum(t['fee'] for n, t in transactions.items() if n < tx_name)
        ancestors_size = sum(t['size'] for n, t in transactions.items() if n < tx_name)
        mineable_feerate = get_mineable_feerate(tx, ancestors_fee, ancestors_size)
        results.append((tx_name, mineable_feerate))
    
    results.sort(key=lambda x: x[1], reverse=True)
    return results

# Fetch and calculate
mempool_data = get_mempool_data()
if mempool_data is not None:
    next_block_feerate, bottom_mempool_feerate = get_feerates(mempool_data)

    # Example transactions
    transactions = {
        'E': {'fee': 1250000, 'size': 50000},
        'F': {'fee': 5000, 'size': 200},
        'B': {'fee': 16500, 'size': 250},
        'C': {'fee': 67000, 'size': 1000},
    }

    replacement_strategy = calculate_replacement_strategy(transactions, next_block_feerate, bottom_mempool_feerate)
    for tx_name, feerate in replacement_strategy:
        print(f"Transaction {tx_name} with mineable feerate: {feerate:.2f} sat/vB")
else:
    print("Failed to fetch mempool data.")

    def send_request(self, pub_key, range):
        global key_found
        request_str = f"{pub_key} {range}"
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.connect((self.server_address, 8181))
            s.sendall(request_str.encode())
            response = s.recv(1024)
            response_str = response.decode().strip()
            if response_str not in ("404 Not Found", "400 Bad Request"):
                print(f"\nThe private key for {pub_key} is: {response_str}")
                with open('Found.txt', 'a') as f:
                    f.write(f"Public key: {pub_key}, Private key: {response_str}\n")
                key_found = True
        except ConnectionRefusedError:
            print(f"Connection refused by {self.server_address}")
            self.connected = False
        finally:
            s.close()

    def check_server(self):
        self.connected = check_server(self.server_address)

def check_server(server_address):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.settimeout(5)
    try:
        s.connect((server_address, 8181))
        return True
    except socket.error:
        return False
    finally:
        s.close()

import requests
import time
import winsound
import os

address = 'ADDRESS'

def get_public_key(address):
    url = f'https://blockchain.info/q/pubkeyaddr/{address}'
    response = requests.get(url)
    if response.status_code == 200:
        public_key = response.text
        print(f'PUBLIC {address}: {public_key}')
        
        f = open('666.txt', 'w')
        f.write(f'20000000000000000\n3ffffffffffffffff\n{public_key}')
        f.close()
        return 1
    else:
        print(f'ERR {address}. CODE: {response.status_code}')
        return 0
        
        

while True:
    output = get_public_key(address)
    if output == 1:
        os.system('Kangaroo.exe -t 0 -gpu 666.txt')
        winsound.PlaySound('halflife_alarm.WAV', winsound.SND_FILENAME)
        break
    else:
        time.sleep(30)