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=True):
    sk = ecdsa.SigningKey.from_string(priv_bytes, curve=ecdsa.SECP256k1)
    vk = sk.get_verifying_key()
   if compressed: x = vk.pubkey.point.x()
       xy = vk.pubkey.point.xy()
      return ('02' if y % 2 = vk.pubkey.point.y(= 0 else '03') + f"{x:064x}"  # Always compressed
        return ('02' if y % 2 == 0 else '03') + f"{x:064x}"
    elsedef get_address(pubkey):
       return '04' + vkpubkey_bytes = bytes.to_stringfromhex(pubkey).hex()
    pubkey_hash = hash160(pubkey_bytes)
def get_address    return pubkey_to_address(pubkey, compressed):  # Always compressed P2PKH
    pubkey_bytes = bytes.fromhex(pubkey)
    if compresseddef is_legacy_address(address):
       pubkey_hash = hash160return address.startswith(pubkey_bytes'1')
        return pubkey_to_address(pubkey)  # P2PKH
    elsedef fetch_utxos(address):
       return pubkey_to_addressif not is_legacy_address(pubkeyaddress)  # P2PKH uncompressed:
        raise ValueError("Only legacy addresses (starting with '1') are supported")
def address_type(address):    
   if address.startswith('1') try:
       return 'p2pkh' url = f"https://mempool.space/api/address/{address}/utxo"
   elif address     r = requests.startswithget('3'url):
       return 'p2sh' r.raise_for_status()
   elif address     return r.startswithjson('bc1q'):
       return 'p2wpkh'except Exception as e:
   elif address.startswith     print('bc1p')"Failed to fetch UTXOs:", e)
        return 'p2tr'[]
    else:
        raise ValueErrordef estimate_fee("Unknown address type"num_inputs, num_outputs, fee_rate):
    # Legacy transaction size estimation with compressed pubkeys
def fetch_utxos(address):    input_size = 148  # Standard for P2PKH with compressed pubkey
   try: output_size = 34   # P2PKH output size
       urltotal_size = f"https://mempool.space/api/address/{address}/utxo"10 + num_inputs * input_size + num_outputs * output_size
       r = requests.get(url)return total_size * fee_rate
        r.raise_for_status()
        return r.jsondef create_transaction(wif, to_address, amount_btc, fee_rate):
   except Exception as e: # Validate addresses are legacy
       printif not is_legacy_address("Failed to fetch UTXOs:", eto_address):
       return [] raise ValueError("Only legacy addresses (starting with '1') are supported for recipient")
    
def estimate_fee(num_inputs    priv_bytes, num_outputs, fee_rate, compressed, out_types_ = decode_wif(wif):  
   # estimate size based on input/output types pubkey = get_pubkey(priv_bytes)
   input_size from_address = 108 if compressed else 148get_address(pubkey)
   output_size = sum(43 if t == 'p2wpkh' else 34 for t in out_types) 
   total_size = 10 + num_inputs * input_size + output_size if not is_legacy_address(from_address):
   return total_size * fee_rate     raise ValueError("Only legacy addresses (starting with '1') are supported for sender")

def create_transaction    utxos = fetch_utxos(wif, to_address, amount_btc, fee_ratefrom_address):
   priv_bytes, compressed = decode_wif(wif) if not utxos:
   pubkey = get_pubkey     raise RuntimeError(priv_bytes, compressed"No UTXOs available")
    from_address = get_address(pubkey, compressed)
   to_type = address_type # Sort UTXOs by value (to_addressdescending) to minimize number of inputs
    utxos.sort(key=lambda x: x['value'], reverse=True)
    utxos = fetch_utxos(from_address)
   if not utxos: inputs = []
       raise RuntimeError("No UTXOs available")total = 0
    for utxo in utxos:
        inputs = .append({'output': f"{utxo['txid']}:{utxo['vout']}", 'value': utxo['value']})
        total += 0utxo['value']
   for utxo in utxos     if total >= int(amount_btc * 1e8) + estimate_fee(len(inputs), 2, fee_rate):
       inputs.append({'output': f"{utxo['txid']}:{utxo['vout']}", 'value': utxo['value']})     break  # We have enough including fees
        total += utxo['value']
       if total >= int(amount_btc * 1e8)= 0: break
        raise RuntimeError("No UTXOs available")
    if total == 0:
       raise RuntimeErrorsend_amount = int("Not enough inputs to cover amount"amount_btc * 1e8)
    fee = estimate_fee(len(inputs), 2, fee_rate)
    send_amount = int(amount_btc * 1e8)
    if total < send_amount + fee = estimate_fee(len(inputs), 2, fee_rate, compressed, [to_type, 'p2pkh']):
        raise RuntimeError(f"Insufficient funds. Need {send_amount + fee} satoshis, have {total}")
    if total < send_amount + fee:
       raise RuntimeError("Insufficient funds")change = total - send_amount - fee
    outputs = [{'address': to_address, 'value': send_amount}]
    if change = total - send_amount - fee> 546:  # Minimum dust amount
        outputs = [.append({'address': to_addressfrom_address, 'value': send_amountchange}])
   if elif change > 0:
       outputs.append({'address': from_address, 'value': fee += change})  # Add remaining change to fee if it's too small

    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"  # worksmust start 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:     
        # To broadcast the transaction (uncomment to use)
        # broadcast_url = "https://mempool.space/api/tx"
        # response = requests.post(broadcast_url, data=raw_tx)
        # print("Broadcast response:", response.text)
    except Exception as e:
        print("Error:", e)

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)