⚡️ Speed up method TxInput.to_json by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for TxInput.to_json in electrum/transaction.py

⏱️ Runtime : 376 microseconds → 354 microseconds (best of 29 runs)

📝 Explanation and details

The optimization targets the witness_elements() method, which is called from the hot path in to_json() when processing witness data. The key performance improvements are:

What was optimized:

1. Pre-allocated list instead of generator comprehension: Replaced list(vds.read_bytes(vds.read_compact_size()) for i in range(n)) with pre-allocated result = [None] * n and explicit loop filling
2. Eliminated repeated attribute lookups: Cached vds.read_bytes and vds.read_compact_size as local variables to avoid attribute resolution overhead in the loop

Why it's faster:

• List pre-allocation eliminates dynamic resizing costs as Python no longer needs to grow the list incrementally during iteration
• Cached method references avoid repeated attribute lookups (vds.read_bytes and vds.read_compact_size) inside the loop, reducing per-iteration overhead
• Generator elimination removes the intermediate iterator object creation and the list() constructor call

Performance impact:
The line profiler shows the critical line improvement: the original list(generator) line took 819,520ns (80.9% of function time) vs the optimized explicit loop taking 772,695ns (72.2% of function time) - about a 6% reduction in the hottest code path.

Test case effectiveness:
The optimization shows strongest gains (6-11%) on test cases with larger witness data structures (large_witness tests showing 9.18% and 9.42% improvements), while smaller witness cases show modest 1-6% gains. This makes sense as the optimization benefits scale with the number of witness elements processed.

The 6% overall speedup directly improves transaction processing performance, particularly beneficial for applications handling many transactions with witness data (SegWit/Taproot transactions).

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 356 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	✅ 2 Passed
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

from typing import Optional, Sequence, Union

# imports
import pytest
from electrum.transaction import TxInput


class SerializationError(Exception):
    pass

class TxOutpoint:
    """Minimal stub for TxOutpoint for testing."""
    def __init__(self, txid: bytes, out_idx: int):
        self.txid = txid
        self.out_idx = out_idx

# ------------------- UNIT TESTS -------------------

# Helper function to create a valid witness (bitcoin compact size encoding)
def create_witness(elements: Sequence[bytes]) -> bytes:
    # Compact size encoding for number of elements
    def encode_compact_size(n):
        if n < 253:
            return bytes([n])
        elif n < 2**16:
            return b'\xfd' + n.to_bytes(2, 'little')
        elif n < 2**32:
            return b'\xfe' + n.to_bytes(4, 'little')
        else:
            return b'\xff' + n.to_bytes(8, 'little')
    result = bytearray()
    result += encode_compact_size(len(elements))
    for el in elements:
        result += encode_compact_size(len(el))
        result += el
    return bytes(result)

# 1. BASIC TEST CASES

def test_to_json_minimal_input():
    # Test with only required fields, no script_sig, no witness, not coinbase
    prevout = TxOutpoint(txid=bytes.fromhex('00'*32), out_idx=1)
    txin = TxInput(prevout=prevout)
    codeflash_output = txin.to_json(); result = codeflash_output # 1.43μs -> 1.28μs (11.8% faster)

def test_to_json_all_fields():
    # Test with all fields set, including script_sig and witness
    prevout = TxOutpoint(txid=bytes.fromhex('a1'*32), out_idx=2)
    script_sig = b'\x01\x02\x03'
    witness_elements = [b'\x04\x05', b'\x06']
    witness = create_witness(witness_elements)
    txin = TxInput(prevout=prevout, script_sig=script_sig, nsequence=123, witness=witness, is_coinbase_output=True)
    codeflash_output = txin.to_json(); result = codeflash_output # 9.24μs -> 9.20μs (0.402% faster)

def test_to_json_script_sig_only():
    # Test with script_sig only
    prevout = TxOutpoint(txid=bytes.fromhex('ff'*32), out_idx=0)
    script_sig = b'\xaa\xbb\xcc'
    txin = TxInput(prevout=prevout, script_sig=script_sig)
    codeflash_output = txin.to_json(); result = codeflash_output # 1.42μs -> 1.29μs (9.60% faster)

def test_to_json_witness_only():
    # Test with witness only
    prevout = TxOutpoint(txid=bytes.fromhex('01'*32), out_idx=3)
    witness_elements = [b'\x00\x01', b'\x02\x03\x04']
    witness = create_witness(witness_elements)
    txin = TxInput(prevout=prevout, witness=witness)
    codeflash_output = txin.to_json(); result = codeflash_output # 8.49μs -> 8.51μs (0.235% slower)

def test_to_json_coinbase_true_false():
    # Test both coinbase True and False
    prevout = TxOutpoint(txid=bytes.fromhex('02'*32), out_idx=4)
    txin_true = TxInput(prevout=prevout, is_coinbase_output=True)
    txin_false = TxInput(prevout=prevout, is_coinbase_output=False)

# 2. EDGE TEST CASES

def test_to_json_empty_script_sig_and_witness():
    # script_sig and witness are empty bytes
    prevout = TxOutpoint(txid=bytes.fromhex('03'*32), out_idx=5)
    txin = TxInput(prevout=prevout, script_sig=b'', witness=b'')
    codeflash_output = txin.to_json(); result = codeflash_output # 2.60μs -> 2.44μs (6.39% faster)

def test_to_json_max_nsequence():
    # nsequence at maximum 0xffffffff
    prevout = TxOutpoint(txid=bytes.fromhex('04'*32), out_idx=6)
    txin = TxInput(prevout=prevout, nsequence=0xffffffff)
    codeflash_output = txin.to_json(); result = codeflash_output # 1.26μs -> 1.24μs (1.62% faster)

def test_to_json_zero_nsequence():
    # nsequence at zero
    prevout = TxOutpoint(txid=bytes.fromhex('05'*32), out_idx=7)
    txin = TxInput(prevout=prevout, nsequence=0)
    codeflash_output = txin.to_json(); result = codeflash_output # 1.19μs -> 1.17μs (2.14% faster)

def test_to_json_prevout_index_zero_and_max():
    # out_idx at 0 and at a large value
    prevout0 = TxOutpoint(txid=bytes.fromhex('06'*32), out_idx=0)
    prevoutmax = TxOutpoint(txid=bytes.fromhex('07'*32), out_idx=2**32-1)
    txin0 = TxInput(prevout=prevout0)
    txinmax = TxInput(prevout=prevoutmax)

def test_to_json_witness_with_zero_elements():
    # witness with zero elements (encoded as 0x00)
    prevout = TxOutpoint(txid=bytes.fromhex('08'*32), out_idx=8)
    witness = create_witness([])
    txin = TxInput(prevout=prevout, witness=witness)
    codeflash_output = txin.to_json(); result = codeflash_output # 6.47μs -> 6.18μs (4.66% faster)

def test_to_json_witness_with_empty_element():
    # witness with one empty element (encoded as 0x01 0x00)
    prevout = TxOutpoint(txid=bytes.fromhex('09'*32), out_idx=9)
    witness = create_witness([b''])
    txin = TxInput(prevout=prevout, witness=witness)
    codeflash_output = txin.to_json(); result = codeflash_output # 8.04μs -> 7.93μs (1.35% faster)



def test_to_json_prevout_non_bytes_txid():
    # prevout txid is not bytes
    with pytest.raises(AttributeError):
        prevout = TxOutpoint(txid='notbytes', out_idx=12)  # type: ignore
        txin = TxInput(prevout=prevout)
        txin.to_json() # 2.00μs -> 1.88μs (6.16% faster)

# 3. LARGE SCALE TEST CASES

def test_to_json_large_script_sig():
    # script_sig with maximum size (e.g., 1000 bytes)
    prevout = TxOutpoint(txid=bytes.fromhex('0c'*32), out_idx=13)
    script_sig = bytes(range(256))*3 + bytes(range(232))  # 1000 bytes
    txin = TxInput(prevout=prevout, script_sig=script_sig)
    codeflash_output = txin.to_json(); result = codeflash_output # 2.92μs -> 2.73μs (7.07% faster)

def test_to_json_large_witness():
    # witness with 100 elements, each 10 bytes
    prevout = TxOutpoint(txid=bytes.fromhex('0d'*32), out_idx=14)
    elements = [bytes([i]*10) for i in range(100)]
    witness = create_witness(elements)
    txin = TxInput(prevout=prevout, witness=witness)
    codeflash_output = txin.to_json(); result = codeflash_output # 64.3μs -> 58.9μs (9.18% faster)

def test_to_json_large_prevout_txid():
    # prevout txid with non-zero bytes (ensure correct hex conversion)
    txid = bytes([i % 256 for i in range(32)])
    prevout = TxOutpoint(txid=txid, out_idx=15)
    txin = TxInput(prevout=prevout)
    codeflash_output = txin.to_json(); result = codeflash_output # 1.35μs -> 1.29μs (4.81% faster)


#------------------------------------------------
import binascii

# imports
import pytest
from electrum.transaction import TxInput

# function to test (already provided above)

# --- Helper Classes for Tests ---

class SerializationError(Exception):
    pass

class TxOutpoint:
    """Minimal stub for TxOutpoint used in tests."""
    def __init__(self, txid: bytes, out_idx: int):
        self.txid = txid
        self.out_idx = out_idx

# --- Test Suite for TxInput.to_json ---

# ---------- BASIC TEST CASES ----------

def test_basic_to_json_minimal():
    """Test minimal TxInput: no script_sig, no witness, not coinbase."""
    prevout = TxOutpoint(txid=bytes.fromhex('aabbccdd' * 8), out_idx=1)
    txin = TxInput(prevout=prevout)
    expected = {
        'prevout_hash': 'aabbccddaabbccddaabbccddaabbccddaabbccddaabbccddaabbccddaabbccdd',
        'prevout_n': 1,
        'coinbase': False,
        'nsequence': 0xffffffff - 1,
    }
    codeflash_output = txin.to_json() # 1.96μs -> 1.86μs (5.38% faster)

def test_basic_to_json_with_scriptsig():
    """Test TxInput with script_sig present."""
    prevout = TxOutpoint(txid=bytes.fromhex('00' * 32), out_idx=0)
    script_sig = b'\x51\x21\x03'  # OP_1, push 3 bytes
    txin = TxInput(prevout=prevout, script_sig=script_sig)
    codeflash_output = txin.to_json(); result = codeflash_output # 1.64μs -> 1.48μs (10.7% faster)

def test_basic_to_json_coinbase_true():
    """Test TxInput with coinbase output True."""
    prevout = TxOutpoint(txid=bytes.fromhex('ff' * 32), out_idx=4294967295)
    txin = TxInput(prevout=prevout, is_coinbase_output=True)
    codeflash_output = txin.to_json(); result = codeflash_output # 1.24μs -> 1.19μs (3.69% faster)

def test_basic_to_json_with_witness():
    """Test TxInput with witness stack containing two elements."""
    prevout = TxOutpoint(txid=bytes.fromhex('11' * 32), out_idx=2)
    # witness: compact size 2 (2 elements), then [compact size 3, b'abc'], [compact size 1, b'z']
    witness_bytes = b'\x02' + b'\x03abc' + b'\x01z'
    txin = TxInput(prevout=prevout, witness=witness_bytes)
    codeflash_output = txin.to_json(); result = codeflash_output # 11.4μs -> 10.8μs (6.34% faster)

def test_basic_to_json_all_fields():
    """Test TxInput with all possible fields set."""
    prevout = TxOutpoint(txid=bytes.fromhex('12345678' * 4), out_idx=5)
    script_sig = b'\x6a\xab\xcd'
    # witness: 1 element, b'\x01x'
    witness_bytes = b'\x01\x01x'
    txin = TxInput(prevout=prevout, script_sig=script_sig, nsequence=42, witness=witness_bytes, is_coinbase_output=True)
    codeflash_output = txin.to_json(); result = codeflash_output # 8.47μs -> 8.17μs (3.69% faster)

# ---------- EDGE TEST CASES ----------

def test_edge_to_json_empty_scriptsig_and_witness():
    """Test TxInput with script_sig and witness as empty bytes."""
    prevout = TxOutpoint(txid=bytes.fromhex('01' * 32), out_idx=0)
    txin = TxInput(prevout=prevout, script_sig=b'', witness=b'')
    codeflash_output = txin.to_json(); result = codeflash_output # 2.46μs -> 2.26μs (8.98% faster)

def test_edge_to_json_large_scriptsig():
    """Test TxInput with very large script_sig (512 bytes)."""
    prevout = TxOutpoint(txid=bytes.fromhex('02' * 32), out_idx=3)
    script_sig = b'\xff' * 512
    txin = TxInput(prevout=prevout, script_sig=script_sig)
    codeflash_output = txin.to_json(); result = codeflash_output # 2.25μs -> 2.01μs (11.7% faster)

def test_edge_to_json_large_witness_elements():
    """Test TxInput with witness stack of 10 elements, each 50 bytes."""
    prevout = TxOutpoint(txid=bytes.fromhex('03' * 32), out_idx=4)
    witness_elements = [bytes([i]) * 50 for i in range(10)]
    # Build witness bytes: compact size 10, then for each: compact size 50 + 50 bytes
    witness_bytes = b'\x0a' + b''.join([b'\x32' + w for w in witness_elements])
    txin = TxInput(prevout=prevout, witness=witness_bytes)
    codeflash_output = txin.to_json(); result = codeflash_output # 14.6μs -> 13.9μs (5.05% faster)

def test_edge_to_json_max_nsequence():
    """Test TxInput with nsequence at maximum uint32 value."""
    prevout = TxOutpoint(txid=bytes.fromhex('04' * 32), out_idx=7)
    txin = TxInput(prevout=prevout, nsequence=0xffffffff)
    codeflash_output = txin.to_json(); result = codeflash_output # 1.26μs -> 1.18μs (6.69% faster)

def test_edge_to_json_zero_prevout():
    """Test TxInput with prevout txid all zeros and out_idx zero."""
    prevout = TxOutpoint(txid=bytes(32), out_idx=0)
    txin = TxInput(prevout=prevout)
    codeflash_output = txin.to_json(); result = codeflash_output # 1.21μs -> 1.20μs (0.831% faster)

def test_edge_to_json_non_bytes_scriptsig():
    """Test TxInput with script_sig as non-bytes (should fail)."""
    prevout = TxOutpoint(txid=bytes.fromhex('ab' * 32), out_idx=1)
    with pytest.raises(AttributeError):
        txin = TxInput(prevout=prevout, script_sig="notbytes")
        txin.to_json() # 2.47μs -> 2.33μs (6.27% faster)



def test_large_scale_to_json_large_scriptsig_and_witness():
    """Test TxInput with large script_sig (999 bytes) and witness (100 elements, 8 bytes each)."""
    prevout = TxOutpoint(txid=bytes.fromhex('de' * 32), out_idx=9)
    script_sig = b'\x01' * 999
    num_elements = 100
    witness_bytes = bytes([num_elements]) + b''.join([b'\x08' + bytes([i]*8) for i in range(num_elements)])
    txin = TxInput(prevout=prevout, script_sig=script_sig, witness=witness_bytes)
    codeflash_output = txin.to_json(); result = codeflash_output # 66.3μs -> 60.6μs (9.42% faster)

def test_large_scale_to_json_various_prevouts():
    """Test 100 TxInputs with different prevout txids and out_idx."""
    for i in range(100):
        txid = bytes([i] * 32)
        out_idx = i
        txin = TxInput(prevout=TxOutpoint(txid=txid, out_idx=out_idx))
        codeflash_output = txin.to_json(); result = codeflash_output # 53.1μs -> 51.2μs (3.66% faster)

def test_large_scale_to_json_scriptsig_and_witness_empty_and_nonempty():
    """Test TxInput with alternating empty/non-empty script_sig and witness for 50 cases."""
    for i in range(50):
        prevout = TxOutpoint(txid=bytes([i] * 32), out_idx=i)
        if i % 2 == 0:
            script_sig = b''
            witness = b''
        else:
            script_sig = bytes([i] * (i+1))
            witness = bytes([1]) + b'\x01' + bytes([i])
        txin = TxInput(prevout=prevout, script_sig=script_sig, witness=witness)
        codeflash_output = txin.to_json(); result = codeflash_output # 94.1μs -> 89.1μs (5.62% faster)
        if i % 2 == 0:
            pass
        else:
            pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from electrum.transaction import TxInput
from electrum.transaction import TxOutpoint

def test_TxInput_to_json():
    TxInput.to_json(TxInput(prevout=TxOutpoint((v1 := b''), 0), script_sig=v1, nsequence=0, witness=v1, is_coinbase_output=False))

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_0kz7t2kd/tmpl_6wd0p_/test_concolic_coverage.py::test_TxInput_to_json	3.28μs	3.16μs	3.86%✅

To edit these changes git checkout codeflash/optimize-TxInput.to_json-mhok06yc and push.