Bitcoin Parser: Understanding Raw Transactions

def parse_varint(data_bytes, offset):
    """
    Parse a variable-length integer (varint) used in Bitcoin transactions.
    
    Bitcoin uses a compact encoding for integers:
    - If value < 0xFD (253): stored as a single byte
    - If value <= 0xFFFF: stored as 0xFD followed by 2 bytes
    - If value <= 0xFFFFFFFF: stored as 0xFE followed by 4 bytes
    - Otherwise: stored as 0xFF followed by 8 bytes
    
    Returns:
        (value, bytes_consumed)
    """
    fbyte = data_bytes[offset]

    if fbyte < 0xFD:
        return (fbyte, 1)
    elif fbyte == 0xFD:
        value = int.from_bytes(data_bytes[offset+1:offset+3], 'little')
        return (value, 3)
    elif fbyte == 0xFE:
        value = int.from_bytes(data_bytes[offset+1:offset+5], 'little')
        return (value, 5)
    else:
        value = int.from_bytes(data_bytes[offset+1:offset+9], 'little')
        return (value, 9)
    
def parse_tx(tx):
    """
    Parse a raw Bitcoin transaction hex string into a structured dictionary.
    
    Transaction structure:
    - Version (4 bytes, little-endian)
    - Input Count (varint)
    - For each input:
        - Previous TX Hash (32 bytes, reversed for display)
        - Output Index (4 bytes, little-endian)
        - ScriptSig Length (varint)
        - ScriptSig (variable bytes)
        - Sequence (4 bytes, little-endian)
    - Output Count (varint)
    - For each output:
        - Amount (8 bytes, little-endian, satoshis)
        - ScriptPubKey Length (varint)
        - ScriptPubKey (variable bytes)
    - Locktime (4 bytes, little-endian)
    """
    hbytes = bytes.fromhex(tx)
    offset = 0

    # Version (4 bytes, little-endian)
    version = int.from_bytes(hbytes[offset:offset+4], 'little')
    offset += 4

    # Input Count (varint)
    input_count, vbytes = parse_varint(hbytes, offset)
    offset += vbytes

    inputs = []
    for _ in range(input_count):
        # Previous Transaction Hash (32 bytes, reversed for display)
        prev_tx_hash = hbytes[offset:offset+32][::-1].hex()
        offset += 32

        # Output Index (4 bytes, little-endian)
        output_index = int.from_bytes(hbytes[offset:offset+4], 'little')
        offset += 4

        # ScriptSig Length (varint)
        scriptSig_len, vbytes = parse_varint(hbytes, offset)
        offset += vbytes

        script_bytes = hbytes[offset:offset+scriptSig_len]
        
        # Parse the ScriptSig (signature + public key)
        pos = 0
        if scriptSig_len == 0:
            der_sign, sighash_type, pub_key = None, None, None
        elif script_bytes[0] == 0x30:
            # DER signature starts with 0x30
            der_len = script_bytes[pos+1]
            der_sign = script_bytes[pos:pos+der_len+2]
            pos += der_len + 2
        else:
            # Handle other cases (rare)
            pos += 1
            der_len = script_bytes[pos+1]
            der_sign = script_bytes[pos:pos+der_len+2]
            pos += der_len + 2

        # Sighash type (1 byte: 0x01 = SIGHASH_ALL)
        sighash_type = script_bytes[pos]
        pos += 1

        # Public key length and value
        pubkey_len = script_bytes[pos]
        pos += 1
        pub_key = script_bytes[pos:pos+pubkey_len]
        offset += scriptSig_len

        # Sequence number (4 bytes, little-endian)
        sequence = int.from_bytes(hbytes[offset:offset+4], 'little')
        offset += 4

        inputs.append({
            "prev_hash": prev_tx_hash,
            "index": output_index,
            "scriptSig_len": scriptSig_len,
            "der_sign": der_sign.hex() if der_sign else None,
            "sighash_type": sighash_type,
            "pub_key": pub_key.hex() if pub_key else None,
            "sequence": sequence
        })

    # Output Count (varint)
    output_count, vbytes = parse_varint(hbytes, offset)
    offset += vbytes

    outputs = []
    for _ in range(output_count):
        # Amount (8 bytes, little-endian, in satoshis)
        amount = int.from_bytes(hbytes[offset:offset+8], 'little')
        offset += 8

        # ScriptPubKey Length (varint)
        script_pubkey_len, vbytes = parse_varint(hbytes, offset)
        offset += vbytes

        # ScriptPubKey (locking script)
        script_pubkey = hbytes[offset:offset+script_pubkey_len].hex()
        offset += script_pubkey_len

        outputs.append({
            "amount_satoshis": amount,
            "amount_btc": amount / 100000000,
            "script_pubkey_len": script_pubkey_len,
            "script_pubkey": script_pubkey
        })

    # Locktime (4 bytes, little-endian)
    locktime = int.from_bytes(hbytes[offset:offset+4], 'little')

    return {
        "version": version,
        "input_count": input_count,
        "inputs": inputs,
        "output_count": output_count,
        "outputs": outputs,
        "locktime": locktime
    }

# Example usage
if __name__ == "__main__":
    # Raw transaction hex (simplified for demonstration)
    tx_hex = "0100000001a530bdca8a35b98eb5a62c196191b9782cb119a19c423f765c32a7d33877f8dd000000008a47304402200102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2002202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f400141040102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f40ffffffff0140420f00000000001976a914000000000000000000000000000000000000000088ac00000000"
    
    result = parse_tx(tx_hex)
    
    print("=" * 60)
    print("BITCOIN TRANSACTION PARSER")
    print("=" * 60)
    print(f"Version:           {result['version']}")
    print(f"Input Count:       {result['input_count']}")
    print("-" * 60)
    
    for i, inp in enumerate(result['inputs']):
        print(f"INPUT #{i+1}:")
        print(f"  Previous TX Hash: {inp['prev_hash']}")
        print(f"  Output Index:     {inp['index']}")
        print(f"  ScriptSig Length: {inp['scriptSig_len']}")
        if inp['der_sign']:
            print(f"  DER Signature:    {inp['der_sign'][:64]}...")
        print(f"  Sighash Type:     {inp['sighash_type']} (SIGHASH_ALL)")
        if inp['pub_key']:
            print(f"  Public Key:       {inp['pub_key'][:64]}...")
        print(f"  Sequence:         {inp['sequence']}")
        print("-" * 60)
    
    print(f"Output Count:      {result['output_count']}")
    for i, out in enumerate(result['outputs']):
        print(f"OUTPUT #{i+1}:")
        print(f"  Amount:          {out['amount_btc']} BTC ({out['amount_satoshis']} satoshis)")
        print(f"  ScriptPubKey Len: {out['script_pubkey_len']}")
        print(f"  ScriptPubKey:     {out['script_pubkey']}")
        print("-" * 60)
    
    print(f"Locktime:          {result['locktime']}")
    print("=" * 60)

# Save the code to a file
python bitcoin_parser.py

# Or run it directly in Python
python -c "exec(open('bitcoin_parser.py').read())"