The ScriptPubKey is a locking script that specifies the conditions that must be met to spend the bitcoins in a transaction output.

Let's examine a real transaction output's ScriptPubKey:

Common ScriptPubKey Types

The most common types of ScriptPubKey patterns are:

Implementation Example

Here's how you might parse a ScriptPubKey:

def parse_scriptpubkey(raw_tx: bytes, offset: int = 0) -> tuple[bytes, int]:
    """
    Parse a ScriptPubKey from raw transaction bytes
    
    Args:
        raw_tx: Raw transaction bytes
        offset: Starting position in bytes
        
    Returns:
        (scriptpubkey, new_offset)
    """
    # Read the script size (varint)
    script_size, offset = read_varint(raw_tx, offset)
    
    # Read the actual script
    script = raw_tx[offset:offset + script_size]
    
    return script, offset + script_size

Locking Mechanisms

The ScriptPubKey acts like a smart contract that defines how the bitcoins can be spent. Common locking mechanisms include:

1. Single Signature: Requires one digital signature from a specific public key
2. Multi-signature: Requires M-of-N signatures from a set of public keys
3. Time Locks: Prevents spending until a certain time or block height
4. Hash Locks: Requires revealing a preimage that hashes to a specific value

Validation Rules

When validating a transaction, nodes must:

1. Verify the ScriptPubKey length matches its declared size
2. Ensure the script follows valid syntax rules
3. Check that the script type is standard (for policy rules)
4. Verify the spending conditions are met when the output is spent

Standard vs Non-Standard Scripts

Bitcoin Core's default policy only relays "standard" transaction types to prevent potential DoS attacks. Standard script types include:

• P2PKH (Pay to Public Key Hash)
• P2SH (Pay to Script Hash)
• P2WPKH (Pay to Witness Public Key Hash)
• P2WSH (Pay to Witness Script Hash)
• P2TR (Pay to Taproot)
• Bare Multisig (limited to 3-of-3)
• OP_RETURN (limited to 83 bytes)