Proof of key ownership without spending

Commits to:
✓ All inputs (their outpoints)
✓ Input sequences (for current input; others set to 0)

Does NOT commit to:
✗ Any outputs (completely blank)
✗ Other inputs' sequences

def apply_sighash_none(tx_copy, input_index):
    # Remove ALL outputs
    tx_copy.outputs = []

    # Set all other inputs' sequences to 0
    for i, inp in enumerate(tx_copy.inputs):
        if i != input_index:
            inp.sequence = 0

    # Current input's sequence is preserved
    return tx_copy

Scenario: Alice creates a SIGHASH_NONE signature for her input.
She intends to send to Bob.

Risk: Anyone who sees this signature can:

1. Take Alice's signed input

2. Create a new transaction with the SAME input but DIFFERENT outputs

3. Send Alice's funds anywhere they want

Alice has signed a "blank check" — she authorized the spend
but left the destination empty for anyone to fill in.

# Proof of key ownership without spending
sighash_none_sig = sign(private_key, sighash_none_preimage)
# Broadcasting this would let miners steal funds, but it proves key ownership

# Creating a SIGHASH_NONE signature (dangerous — educational purposes only)
def sign_sighash_none(private_key, tx, input_index, script_code):
    # Modified tx: no outputs, other sequences zeroed
    tx_copy = copy_transaction(tx)
    tx_copy.outputs.clear()
    for i in range(len(tx_copy.inputs)):
        if i != input_index:
            tx_copy.inputs[i].sequence = 0
    tx_copy.inputs[input_index].script = script_code
    for i in range(len(tx_copy.inputs)):
        if i != input_index:
            tx_copy.inputs[i].script = b''

    preimage = tx_copy.serialize() + struct.pack('<I', SIGHASH_NONE)
    z = double_sha256(preimage)
    der_sig = ecdsa_sign_der(private_key, z)
    return der_sig + bytes([SIGHASH_NONE])