Building a Target and Bits Converter in Pure Python

To understand how a Bitcoin full node parses, decompresses, and validates cryptographic difficulty parameters inside block headers, we can implement a custom Target Calculator in Python.

By writing this from scratch using only Python's standard libraries, we can model how the 4-byte compact bits field is decompressed into a full 256-bit target integer, how difficulty is calculated relative to Satoshi's Difficulty 1 reference, and how a raw block hash is evaluated for Proof of Work validation.

💻 1. The Target Calculator Source Code

Save the following standard-library Python script as python_target_calculator.py.

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}")