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)