⚡️ Speed up method TxOutput.to_json by 5%

[codeflash-ai]

📄 5% (0.05x) speedup for TxOutput.to_json in electrum/transaction.py

⏱️ Runtime : 10.6 milliseconds → 10.1 milliseconds (best of 48 runs)

📝 Explanation and details

Optimizations Applied:

• Added __slots__ to TxOutput to prevent per-instance __dict__ allocation, improving both memory usage and attribute access speed.
• Moved parse_max_spend(value) to a local variable to ensure it's evaluated at most once, saving a redundant function call when the result must be checked.
• Used a direct dict literal in to_json for maximal performance (no intermediate variable allocation).
• No behavioral changes and all comments/type annotations are preserved as required.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Union

# imports
import pytest  # used for our unit tests
from electrum.transaction import TxOutput


def parse_max_spend(value):
    # Dummy implementation for testing purposes
    # Accepts only string "max" or strings starting with "max:"
    if isinstance(value, str) and (value == "max" or value.startswith("max:")):
        return value
    return None
from electrum.transaction import TxOutput

# unit tests

# ---------------------------
# 1. Basic Test Cases
# ---------------------------

def test_to_json_basic_int_value():
    # Test with a normal integer value
    txout = TxOutput(scriptpubkey=b'\x01\x02\x03', value=1000)
    codeflash_output = txout.to_json(); result = codeflash_output # 7.06μs -> 6.98μs (1.06% faster)



def test_to_json_zero_value():
    # Test with value zero
    txout = TxOutput(scriptpubkey=b'\x00\x00\x00', value=0)
    codeflash_output = txout.to_json(); result = codeflash_output # 17.7μs -> 17.8μs (0.399% slower)

def test_to_json_negative_value():
    # Test with negative value (should be allowed if int)
    txout = TxOutput(scriptpubkey=b'\x01', value=-1)
    codeflash_output = txout.to_json(); result = codeflash_output # 4.39μs -> 4.46μs (1.44% slower)

def test_to_json_empty_scriptpubkey():
    # Test with empty scriptpubkey
    txout = TxOutput(scriptpubkey=b'', value=123)
    codeflash_output = txout.to_json(); result = codeflash_output # 11.1μs -> 10.7μs (3.15% faster)

def test_to_json_large_scriptpubkey():
    # Test with a large scriptpubkey
    large_bytes = bytes(range(256))
    txout = TxOutput(scriptpubkey=large_bytes, value=999)
    codeflash_output = txout.to_json(); result = codeflash_output # 32.1μs -> 32.0μs (0.331% faster)

def test_to_json_invalid_value_type():
    # Test with an invalid value type (should raise ValueError)
    with pytest.raises(ValueError):
        TxOutput(scriptpubkey=b'\x01\x02', value=[1,2,3])

def test_to_json_invalid_value_str():
    # Test with an invalid string value (should raise ValueError)
    with pytest.raises(ValueError):
        TxOutput(scriptpubkey=b'\x01\x02', value='notmax')

def test_to_json_non_bytes_scriptpubkey():
    # Test with non-bytes scriptpubkey (should not raise, but hex() will fail in to_json)
    txout = TxOutput(scriptpubkey=b'abc', value=42)
    codeflash_output = txout.to_json(); result = codeflash_output # 14.3μs -> 14.2μs (0.926% faster)

# ---------------------------
# 3. Large Scale Test Cases
# ---------------------------

def test_to_json_many_outputs():
    # Test scalability with many outputs
    outputs = []
    for i in range(1000):
        txout = TxOutput(scriptpubkey=bytes([i % 256]), value=i)
        outputs.append(txout.to_json()) # 5.16ms -> 4.91ms (5.10% faster)

def test_to_json_large_scriptpubkey_and_value():
    # Test with scriptpubkey of 999 bytes and large int value
    scriptpubkey = bytes([42]*999)
    value = 2**60
    txout = TxOutput(scriptpubkey=scriptpubkey, value=value)
    codeflash_output = txout.to_json(); result = codeflash_output # 15.9μs -> 15.9μs (0.057% faster)


def test_to_json_mutation_resistance():
    # Changing any field should change the output
    txout1 = TxOutput(scriptpubkey=b'\x01\x02', value=100)
    txout2 = TxOutput(scriptpubkey=b'\x01\x02', value=101)
    txout3 = TxOutput(scriptpubkey=b'\x01\x03', value=100)
    codeflash_output = txout1.to_json() # 14.6μs -> 14.3μs (2.08% faster)
    codeflash_output = txout1.to_json() # 521ns -> 514ns (1.36% faster)

def test_to_json_output_structure():
    # Output should always have the same keys
    txout = TxOutput(scriptpubkey=b'\x01\x02', value=100)
    codeflash_output = txout.to_json(); result = codeflash_output # 11.8μs -> 11.6μs (1.90% faster)

def test_to_json_value_types():
    # Ensure value_sats type matches input
    txout1 = TxOutput(scriptpubkey=b'\x01\x02', value=100)
    txout2 = TxOutput(scriptpubkey=b'\x01\x02', value='max')
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from typing import Union

# imports
import pytest  # used for our unit tests
from electrum.transaction import TxOutput


def parse_max_spend(val):
    # Dummy implementation for testing purposes
    # Accepts only the string "max"
    return val if isinstance(val, str) and val == "max" else None
from electrum.transaction import TxOutput

# unit tests

# -------------------------
# 1. Basic Test Cases
# -------------------------

def test_to_json_basic_int_value():
    # Test with typical scriptpubkey and integer value
    txout = TxOutput(scriptpubkey=b'\x76\xa9\x14', value=123456789)
    codeflash_output = txout.to_json(); result = codeflash_output # 5.67μs -> 5.58μs (1.68% faster)


def test_to_json_basic_empty_scriptpubkey():
    # Test with empty scriptpubkey
    txout = TxOutput(scriptpubkey=b'', value=42)
    codeflash_output = txout.to_json(); result = codeflash_output # 13.1μs -> 12.9μs (1.36% faster)

def test_to_json_basic_zero_value():
    # Test with value 0 (minimum valid integer)
    txout = TxOutput(scriptpubkey=b'\x12\x34', value=0)
    codeflash_output = txout.to_json(); result = codeflash_output # 4.83μs -> 4.84μs (0.227% slower)

# -------------------------
# 2. Edge Test Cases
# -------------------------

def test_to_json_edge_negative_value():
    # Test with negative integer value (should be allowed by constructor)
    txout = TxOutput(scriptpubkey=b'\xff', value=-1)
    codeflash_output = txout.to_json(); result = codeflash_output # 11.5μs -> 11.4μs (1.11% faster)

def test_to_json_edge_large_integer():
    # Test with a very large integer value
    large_value = 2**63 - 1
    txout = TxOutput(scriptpubkey=b'\x01\x02\x03', value=large_value)
    codeflash_output = txout.to_json(); result = codeflash_output # 5.09μs -> 5.00μs (1.70% faster)

def test_to_json_edge_non_max_str_value():
    # Test with a string value that is not 'max' (should raise ValueError)
    with pytest.raises(ValueError):
        TxOutput(scriptpubkey=b'\x00', value='notmax')

def test_to_json_edge_none_value():
    # Test with None as value (should raise ValueError)
    with pytest.raises(ValueError):
        TxOutput(scriptpubkey=b'\x00', value=None)

def test_to_json_edge_float_value():
    # Test with float value (should raise ValueError)
    with pytest.raises(ValueError):
        TxOutput(scriptpubkey=b'\x00', value=1.23)

def test_to_json_edge_bytes_value():
    # Test with bytes as value (should raise ValueError)
    with pytest.raises(ValueError):
        TxOutput(scriptpubkey=b'\x00', value=b'123')

def test_to_json_edge_empty_str_value():
    # Test with empty string as value (should raise ValueError)
    with pytest.raises(ValueError):
        TxOutput(scriptpubkey=b'\x00', value='')

def test_to_json_edge_scriptpubkey_non_bytes():
    # Test with scriptpubkey not bytes (should raise TypeError on hex())
    txout = TxOutput(scriptpubkey='notbytes'.encode(), value=1)
    codeflash_output = txout.to_json(); result = codeflash_output # 14.5μs -> 14.2μs (2.64% faster)

# -------------------------
# 3. Large Scale Test Cases
# -------------------------

def test_to_json_large_scriptpubkey():
    # Test with a large scriptpubkey (999 bytes)
    scriptpubkey = bytes(range(256)) * 3 + bytes(range(231))
    txout = TxOutput(scriptpubkey=scriptpubkey, value=99999999)
    codeflash_output = txout.to_json(); result = codeflash_output # 96.0μs -> 94.3μs (1.79% faster)

def test_to_json_large_value_list():
    # Test creating multiple TxOutput objects and serializing them
    outputs = [
        TxOutput(scriptpubkey=bytes([i % 256]), value=i)
        for i in range(1000)
    ]
    # Check that each to_json output is correct
    for i, txout in enumerate(outputs):
        codeflash_output = txout.to_json(); result = codeflash_output # 5.17ms -> 4.89ms (5.54% faster)


def test_to_json_performance_large_batch():
    # Test performance for a batch of 1000 outputs
    outputs = [
        TxOutput(scriptpubkey=b'\x00\x01', value=i)
        for i in range(1000)
    ]
    # Serialize all outputs
    json_outputs = [txout.to_json() for txout in outputs]
    # Check that all outputs are correct
    for i, result in enumerate(json_outputs):
        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 TxOutput

def test_TxOutput_to_json():
    TxOutput.to_json(TxOutput(scriptpubkey=b'', value=0))

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_0kz7t2kd/tmp8aawtq1m/test_concolic_coverage.py::test_TxOutput_to_json	12.9μs	12.8μs	0.732%✅

To edit these changes git checkout codeflash/optimize-TxOutput.to_json-mhoixwdc and push.