import binascii
import hmac
import hashlib
from mnemonic import Mnemonic

# Given 24-word mnemonics
mnemonic_en = "gesture nation future coil letter uphold sketch crack minimum color carry field solve axis eye tag equal equip play moon input radar omit icon"
mnemonic_cz = "lopuch pastelka levobok fronta obvinit vytesat strach helma oslovit fyzika doufat krtek tabletka capart korpus usednout kniha knot pozvat oves naprosto rektor plout mutace"

# Function to derive entropy and checksum from mnemonic
def get_entropy_and_checksum(mnemo, mnemonic, label):
    # Get the wordlist
    wordlist = mnemo.wordlist
   
    # Convert mnemonic words to indices (11 bits each)
    words = mnemonic.split()
    indices = [wordlist.index(word) for word in words]
   
    # Convert indices to binary (11 bits each, total 264 bits)
    bits = ''.join(bin(index)[2:].zfill(11) for index in indices)
   
    # Extract entropy (first 256 bits) and checksum (last 8 bits)
    entropy_bits = bits[:256]
    checksum_bits = bits[256:]
   
    # Convert entropy bits to bytes (256 bits = 32 bytes)
    entropy_int = int(entropy_bits, 2)
    entropy_bytes = entropy_int.to_bytes(32, 'big')
    entropy_hex = binascii.hexlify(entropy_bytes).decode('utf-8')
   
    # Compute expected checksum: first 8 bits of SHA256(entropy)
    sha256_hash = hashlib.sha256(entropy_bytes).digest()
    expected_checksum_bits = bin(int.from_bytes(sha256_hash, 'big'))[2:].zfill(256)[:8]
   
    # Convert checksum to hex for display
    checksum_int = int(checksum_bits, 2)
    checksum_hex = hex(checksum_int)[2:].zfill(2)
    expected_checksum_hex = hex(int(expected_checksum_bits, 2))[2:].zfill(2)
   
    # Print results
    print(f"\n--- {label} ---")
    print(f"Entropy (hex): {entropy_hex}")
    print(f"Checksum (bits): {checksum_bits}")
    print(f"Checksum (hex): {checksum_hex}")
    print(f"Expected Checksum (bits): {expected_checksum_bits}")
    print(f"Expected Checksum (hex): {expected_checksum_hex}")
    print(f"Checksum Match: {checksum_bits == expected_checksum_bits}")
   
    return entropy_bytes

# Function to derive master private key from a mnemonic
def derive_master_private_key(mnemo, mnemonic, passphrase, label):
    # Derive seed
    seed = mnemo.to_seed(mnemonic, passphrase=passphrase)
   
    # Derive master key using HMAC-SHA512 with "Bitcoin seed"
    h = hmac.new(b"Bitcoin seed", seed, hashlib.sha512).digest()
    master_private_key = h[:32]  # First 32 bytes
    master_chain_code = h[32:]   # Last 32 bytes (not needed for output)
   
    # Convert master private key to hex
    master_private_key_hex = binascii.hexlify(master_private_key).decode('utf-8')
   
    # Print results
    print(f"Master Private Key: {master_private_key_hex}")
   
    return master_private_key_hex

# Initialize mnemonic objects
mnemo_en = Mnemonic("english")
mnemo_cz = Mnemonic("czech")

# English derivations
print("English Mnemonic Derivations:")
entropy_en = get_entropy_and_checksum(mnemo_en, mnemonic_en, "English Mnemonic")
derive_master_private_key(mnemo_en, mnemonic_en, "arizona", "English with Passphrase 'arizona'")
derive_master_private_key(mnemo_en, mnemonic_en, "", "English without Passphrase")

# Czech derivations
print("\nCzech Mnemonic Derivations:")
entropy_cz = get_entropy_and_checksum(mnemo_cz, mnemonic_cz, "Czech Mnemonic")
derive_master_private_key(mnemo_cz, mnemonic_cz, "arizona", "Czech with Passphrase 'arizona'")
derive_master_private_key(mnemo_cz, mnemonic_cz, "", "Czech without Passphrase")