import hashlib
import struct

class BitcoinTargetCalculator:
 def __init__(self):
 # Difficulty 1 Target reference constant (Target_max)
 self.target_max_hex = "00000000ffff0000000000000000000000000000000000000000000000000000"
 self.target_max = int(self.target_max_hex, 16)

 def bits_to_target(self, bits_val: int) -> int:
 """
 Decompresses a 4-byte 'bits' integer from a block header into a 256-bit target.
 """
 # Exponent is the most significant byte (bits_val >> 24)
 exponent = bits_val >> 24

 # Coefficient is the remaining 3 bytes (bits_val & 0xffffff)
 coefficient = bits_val & 0xffffff

 if exponent <= 3:
 # Shift right if exponent is extremely small
 target = coefficient >> (8 * (3 - exponent))
 else:
 # Standard scientific base-256 multiplication
 target = coefficient << (8 * (exponent - 3))

 # Ensure target does not exceed the consensus max target threshold
 if target > self.target_max:
 target = self.target_max

 return target

 def target_to_bits(self, target: int) -> int:
 """
 Compresses a 256-bit target integer into the 4-byte 'bits' compact format.
 """
 if target <= 0:
 return 0

 # Convert target to raw hex bytes representing its value
 hex_str = f"{target:064x}"
 target_bytes = bytes.fromhex(hex_str)

 # Locate the first non-zero byte to define our scientific coefficient digits
 first_non_zero = 0
 while first_non_zero < len(target_bytes) and target_bytes[first_non_zero] == 0:
 first_non_zero += 1

 exponent = len(target_bytes) - first_non_zero

 # Extract the coefficient bytes (up to 3 bytes starting from the first non-zero byte)
 coeff_bytes = target_bytes[first_non_zero:first_non_zero+3]

 # De-serialize the coefficient to integer format (big-endian)
 coefficient = int.from_bytes(coeff_bytes, byteorder="big")

 # Check if the highest bit of the coefficient is set (sign-bit restriction check)
 # If set, we prepend an extra zero byte (which increments exponent)
 if coefficient & 0x800000:
 coefficient >>= 8
 exponent += 1

 # Pack back to 4-byte 'bits': (exponent << 24) | coefficient
 return (exponent << 24) | (coefficient & 0xffffff)

 def calculate_difficulty(self, target: int) -> float:
 """
 Returns the human-readable difficulty relative to Satoshi's max target baseline.
 """
 if target == 0:
 return float('inf')
 return self.target_max / target

 def verify_proof_of_work(self, header_bytes: bytes, bits_val: int) -> bool:
 """
 Performs double-SHA256 hashing and checks if the hash satisfies target difficulty.
 """
 # 1. Calculate double-SHA256
 hash_1 = hashlib.sha256(header_bytes).digest()
 hash_2 = hashlib.sha256(hash_1).digest()

 # Convert hash output to 256-bit integer (interpreting in little-endian format)
 hash_int = int.from_bytes(hash_2, byteorder="little")

 # 2. Decompress Target
 target = self.bits_to_target(bits_val)

 # Show diagnostic logs
 print(f"[+] Computed Block Hash: {hash_2[::-1].hex()}")
 print(f"[+] Active Target: {target:064x}")

 # 3. Evaluate inequality
 return hash_int < target

# --- TESTING AND SIMULATION LOGS ---
if __name__ == "__main__":
 calc = BitcoinTargetCalculator()

 # Let's test using real historical mainnet block 830391 parameters
 # Bits = 0x1703a3d5
 bits_input = 0x1703a3d5

 print("=== Bitcoin Target Decompression ===")
 target_decompressed = calc.bits_to_target(bits_input)
 print(f"[*] Raw Bits Field Input: {hex(bits_input)}")
 print(f"[✔] Decompressed Target: {target_decompressed:064x}")

 print("\n=== Bitcoin Target Compression ===")
 bits_compressed = calc.target_to_bits(target_decompressed)
 print(f"[*] Input Target: {target_decompressed:064x}")
 print(f"[✔] Compressed Bits Output: {hex(bits_compressed)}")

 print("\n=== Bitcoin Difficulty Scaling ===")
 difficulty = calc.calculate_difficulty(target_decompressed)
 print(f"[✔] Active Mining Difficulty: {difficulty:,.2f}")

 print("\n=== Cryptographic Proof of Work Validation ===")
 # Let's mock a valid block header (using real block 830391 elements)
 version = struct.pack("<i", 536870912)
 prev_hash = bytes.fromhex("0000000000000000000201a4e1564f26db9b6426db4bf6ef4f1d4f2bd3f45f2c")[::-1]
 merkle_root = bytes.fromhex("f96f9a721dfbb38640be2ea2f7e02e1c322b64d46747b0e12bd78d91c28c89b7")[::-1]
 time_stamp = struct.pack("<I", 1707865500)
 bits_bytes = struct.pack("<I", bits_input)
 # The valid Nonce resolved by miners for this specific block: 1111666992
 valid_nonce = struct.pack("<I", 1111666992)

 mock_header = version + prev_hash + merkle_root + time_stamp + bits_bytes + valid_nonce

 # Run audit
 is_valid = calc.verify_proof_of_work(mock_header, bits_input)
 print(f"[✔] Mathematical PoW Validation Result: {is_valid}")

 # Try invalidating the header by modifying a single bit of the nonce
 print("\n[*] Corrupting nonce to simulate an invalid block...")
 invalid_nonce = struct.pack("<I", 1111666993) # Increment by 1
 corrupt_header = version + prev_hash + merkle_root + time_stamp + bits_bytes + invalid_nonce

 is_valid_corrupt = calc.verify_proof_of_work(corrupt_header, bits_input)
 print(f"[✔] Mathematical PoW Validation Result (Corrupted Nonce): {is_valid_corrupt}")