python3 -c "import requests; import sys; address = sys.argv[1]; url = f'https://mempool.space/api/address/{address}/txs/chain'; r = requests.get(url); txs = r.json(); pubkey = next((vin['scriptsig'][-66:] for tx in txs for vin in tx['vin'] if 'scriptsig' in vin), None); print(f'Public key for address {address}: {pubkey}' if pubkey else 'Public key not found');" 1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU

url = f'http://mempool.localhost/api/address/{address}/txs/chain'

import base58
import requests
import ecdsa
from bitcoin import *
import hashlib

def decode_wif(wif):
    b = base58.b58decode(wif)
    if len(b) == 38 and b[-5] == 0x01:
        return b[1:-5], True  # compressed
    elif len(b) == 37:
        return b[1:-1], False  # uncompressed
    raise ValueError("Invalid WIF format")

def get_pubkey(priv_bytes, compressed):
    sk = ecdsa.SigningKey.from_string(priv_bytes, curve=ecdsa.SECP256k1)
    vk = sk.get_verifying_key()
    if compressed:
        x = vk.pubkey.point.x()
        y = vk.pubkey.point.y()
        return ('02' if y % 2 == 0 else '03') + f"{x:064x}"
    else:
        return '04' + vk.to_string().hex()

def get_address(pubkey, compressed):
    pubkey_bytes = bytes.fromhex(pubkey)
    if compressed:
        pubkey_hash = hash160(pubkey_bytes)
        return pubkey_to_address(pubkey)  # P2PKH
    else:
        return pubkey_to_address(pubkey)  # P2PKH uncompressed

def address_type(address):
    if address.startswith('1'):
        return 'p2pkh'
    elif address.startswith('3'):
        return 'p2sh'
    elif address.startswith('bc1q'):
        return 'p2wpkh'
    elif address.startswith('bc1p'):
        return 'p2tr'
    else:
        raise ValueError("Unknown address type")

def fetch_utxos(address):
    try:
        url = f"https://mempool.space/api/address/{address}/utxo"
        r = requests.get(url)
        r.raise_for_status()
        return r.json()
    except Exception as e:
        print("Failed to fetch UTXOs:", e)
        return []

def estimate_fee(num_inputs, num_outputs, fee_rate, compressed, out_types):
    # estimate size based on input/output types
    input_size = 108 if compressed else 148
    output_size = sum(43 if t == 'p2wpkh' else 34 for t in out_types)
    total_size = 10 + num_inputs * input_size + output_size
    return total_size * fee_rate

def create_transaction(wif, to_address, amount_btc, fee_rate):
    priv_bytes, compressed = decode_wif(wif)
    pubkey = get_pubkey(priv_bytes, compressed)
    from_address = get_address(pubkey, compressed)
    to_type = address_type(to_address)

    utxos = fetch_utxos(from_address)
    if not utxos:
        raise RuntimeError("No UTXOs available")

    inputs = []
    total = 0
    for utxo in utxos:
        inputs.append({'output': f"{utxo['txid']}:{utxo['vout']}", 'value': utxo['value']})
        total += utxo['value']
        if total >= int(amount_btc * 1e8): break

    if total == 0:
        raise RuntimeError("Not enough inputs to cover amount")

    send_amount = int(amount_btc * 1e8)
    fee = estimate_fee(len(inputs), 2, fee_rate, compressed, [to_type, 'p2pkh'])

    if total < send_amount + fee:
        raise RuntimeError("Insufficient funds")

    change = total - send_amount - fee
    outputs = [{'address': to_address, 'value': send_amount}]
    if change > 0:
        outputs.append({'address': from_address, 'value': change})

    tx = mktx(inputs, outputs)
    for i in range(len(inputs)):
        tx = sign(tx, i, wif)
    return tx

# === Example Usage ===
if __name__ == "__main__":
    WIF = "<wif_private_key>"
    TO_ADDRESS = "1YourLegacyAddressHere"  # works with 1..., 3..., bc1q..., bc1p...
    AMOUNT_BTC = 6.70013241
    FEE_RATE = 20  # sats/vB

    try:
        raw_tx = create_transaction(WIF, TO_ADDRESS, AMOUNT_BTC, FEE_RATE)
        print("Raw Transaction:", raw_tx)
    except Exception as e:
        print("Error:", e)

import cv2
import numpy as np
import random
import time
from bitcoinlib.keys import Key

# Configuration
IMAGE_PATH = 'bitcoin-lvl5-puzzle.png'
EXPECTED_ADDRESS = '1cryptoGeCRiTzVgxBQcKFFjSVydN1GW7'
THRESHOLD_BINARY = 127
SLEEP_BETWEEN_ITERATIONS = 0.6  # Set 0 for maximum speed
MAX_ITERATIONS = None           # Set to an integer to limit attempts

# Load Image
def load_image(path):
    image = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
    if image is None:
        raise FileNotFoundError(f"Image not found: {path}")
    _, binary = cv2.threshold(image, THRESHOLD_BINARY, 255, cv2.THRESH_BINARY)
    return binary

# Extract Shell Areas from Image
def find_shell_contours(image):
    contours, hierarchy = cv2.findContours(image, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    shell_areas = []
    boxes = []

    for i, cnt in enumerate(contours):
        parent = hierarchy[0][i][3]
        if parent != -1:
            outer_cnt = contours[parent]
            outer_area = cv2.contourArea(outer_cnt)
            inner_area = cv2.contourArea(cnt)
            shell_area = outer_area - inner_area

            x, y, w, h = cv2.boundingRect(outer_cnt)
            shell_areas.append(shell_area)
            boxes.append((x, y, w, h))

    # Sort rectangles top-to-bottom, then left-to-right
    combined = list(zip(shell_areas, boxes))
    sorted_combined = sorted(combined, key=lambda item: (round(item[1][1] / 10), item[1][0]))
    sorted_areas = [item[0] for item in sorted_combined]
    return sorted_areas

# Pair Shell Areas into Bytes
def pairwise_to_bytes(areas, strategy='random'):
    bytes_out = []
    if strategy == 'random':
        indices = list(range(len(areas)))
        random.shuffle(indices)
        for i in range(0, len(indices), 2):
            if i + 1 < len(indices):
                a = areas[indices[i]]
                b = areas[indices[i + 1]]
                bytes_out.append(int(a + b) % 256)
    else:  # default to sequential
        for i in range(0, len(areas), 2):
            if i + 1 < len(areas):
                total = areas[i] + areas[i + 1]
                bytes_out.append(int(total) % 256)
    return bytes_out

# Validate Candidate Key
def validate_key(byte_list):
    if len(byte_list) != 32:
        return None, None, False
    hex_key = ''.join(f"{b:02x}" for b in byte_list)
    try:
        key = Key(import_key=hex_key)
        address = key.address()
        is_match = (address == EXPECTED_ADDRESS)
        return hex_key, address, is_match
    except Exception:
        return hex_key, None, False

# Main Loop
def main_loop():
    print("[*] Loading and analyzing image...")
    binary = load_image(IMAGE_PATH)
    original_areas = find_shell_contours(binary)

    if len(original_areas) < 64:
        print("Error: Fewer than 64 rectangles detected. Check image or detection logic.")
        return

    print(f"[+] Starting infinite decode loop ({len(original_areas)} rectangles)...")

    iteration = 0
    while True:
        iteration += 1
        print(f"\n--- Iteration {iteration} ---")

        # Copy and apply white-line pixel hint modifications
        areas = original_areas[:64].copy()
        areas[39] += 17  # Rectangle #40
        areas[52] += 6   # Rectangle #53

        # Random pairing strategy
        byte_list = pairwise_to_bytes(areas, strategy='random')

        # Validate derived private key
        hex_key, address, is_valid = validate_key(byte_list)

        print(f"Private Key (hex): {hex_key}")
        print(f"BTC Address: {address}")
        print(f"Matches Expected: {is_valid}")

        if is_valid:
            print("\nSUCCESS! Matching key found!")
            with open("winning_key.txt", "w") as f:
                f.write(f"Private Key (hex): {hex_key}\n")
                f.write(f"BTC Address: {address}\n")
            break

        if MAX_ITERATIONS and iteration >= MAX_ITERATIONS:
            print("Reached max iterations. Stopping.")
            break

        time.sleep(SLEEP_BETWEEN_ITERATIONS)


if __name__ == "__main__":
    main_loop()

import random
import hashlib
import base58

for puzzle in range(1, 161):
      lower = 2 ** (puzzle - 1)
      upper = (2 ** puzzle) - 1
      seed = "SatoshiNakamotoPuzzle" + str(puzzle)
      random.seed(seed)
      dec = random.randint(lower, upper)
      private_key_hex = "%064x" %  dec
      private_key_bytes = bytes.fromhex(private_key_hex)
      extended_key = b'\x80' + private_key_bytes
      extended_key += b'\x01'
      checksum = hashlib.sha256(hashlib.sha256(extended_key).digest()).digest()[:4]
      wif_bytes = extended_key + checksum
      wif_compressed = base58.b58encode(wif_bytes).decode()
      print(f"Puzzle = {puzzle} {DEC} = {dec} seed = {seed} wif = {wif_compressed}")

#pragma pack(push,1)
struct DPSlot{ fp_t fp; Scalar256 key; };
#pragma pack(pop)
static_assert(sizeof(DPSlot)==40);