⚡️ Speed up method PartialTransaction.requires_keystore by 41%

[codeflash-ai]

📄 41% (0.41x) speedup for PartialTransaction.requires_keystore in electrum/transaction.py

⏱️ Runtime : 334 microseconds → 238 microseconds (best of 250 runs)

📝 Explanation and details

The optimization replaces the all() builtin with generator expression with an explicit for-loop that enables early return. This yields a 40% speedup by eliminating several performance bottlenecks:

Key optimizations:

1. Early exit optimization: The explicit loop returns True immediately upon finding the first input without make_witness, avoiding unnecessary checks of remaining inputs. The original all() approach must evaluate every input even when the result is already determined.

2. Eliminated generator overhead: The original code creates a generator expression that gets consumed by all(), adding Python object creation and iteration protocol overhead. The optimized version uses a direct C-level for-loop over self._inputs.

3. Removed method call indirection: Instead of calling self.inputs() which just returns self._inputs, the optimized version accesses self._inputs directly, eliminating one function call per execution.

Performance characteristics by test case:

• Best speedup (130-155%) occurs when inputs lack make_witness attributes, as early exit triggers immediately
• Moderate speedup (95-130%) for mixed scenarios where some inputs have the attribute
• Consistent speedup (30-35%) even for large inputs (1000+ items) where all inputs must be checked, due to reduced per-iteration overhead

The optimization is particularly effective for Bitcoin transaction processing where checking witness capabilities is common, and transactions often have inputs that require keystore access (missing make_witness). The early exit pattern makes the function highly efficient for the common case where signing requires private keys.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Sequence

# imports
import pytest
from electrum.transaction import PartialTransaction


class PartialTxInput:
    """A dummy PartialTxInput class for testing."""
    pass

class PartialTxInputWithWitness(PartialTxInput):
    """A PartialTxInput subclass with 'make_witness' attribute."""
    def make_witness(self):
        return "witness"

# unit tests

# Basic Test Cases

def test_requires_keystore_empty_inputs():
    # Test with no inputs: should return False (no keystore needed)
    tx = PartialTransaction()
    codeflash_output = tx.requires_keystore() # 1.23μs -> 515ns (139% faster)

def test_requires_keystore_all_inputs_have_make_witness():
    # All inputs have 'make_witness': should return False
    tx = PartialTransaction()
    tx._inputs = [PartialTxInputWithWitness(), PartialTxInputWithWitness()]
    codeflash_output = tx.requires_keystore() # 1.57μs -> 801ns (95.5% faster)

def test_requires_keystore_some_inputs_missing_make_witness():
    # One input lacks 'make_witness': should return True
    tx = PartialTransaction()
    tx._inputs = [PartialTxInputWithWitness(), PartialTxInput()]
    codeflash_output = tx.requires_keystore() # 1.73μs -> 743ns (133% faster)

def test_requires_keystore_no_inputs_have_make_witness():
    # All inputs lack 'make_witness': should return True
    tx = PartialTransaction()
    tx._inputs = [PartialTxInput(), PartialTxInput()]
    codeflash_output = tx.requires_keystore() # 1.47μs -> 637ns (130% faster)

# Edge Test Cases

def test_requires_keystore_single_input_with_make_witness():
    # Single input with 'make_witness': should return False
    tx = PartialTransaction()
    tx._inputs = [PartialTxInputWithWitness()]
    codeflash_output = tx.requires_keystore() # 1.44μs -> 697ns (107% faster)

def test_requires_keystore_single_input_without_make_witness():
    # Single input without 'make_witness': should return True
    tx = PartialTransaction()
    tx._inputs = [PartialTxInput()]
    codeflash_output = tx.requires_keystore() # 1.48μs -> 646ns (129% faster)

def test_requires_keystore_mixed_types():
    # Inputs are a mix of types, some with 'make_witness', some without
    class CustomInput:
        pass
    class CustomInputWithWitness:
        def make_witness(self): pass

    tx = PartialTransaction()
    tx._inputs = [CustomInputWithWitness(), CustomInput(), PartialTxInputWithWitness()]
    codeflash_output = tx.requires_keystore() # 1.93μs -> 979ns (96.8% faster)

def test_requires_keystore_input_with_make_witness_as_property():
    # Input has 'make_witness' as a property, not a method
    class InputWithWitnessProperty:
        @property
        def make_witness(self):
            return "witness"
    tx = PartialTransaction()
    tx._inputs = [InputWithWitnessProperty()]
    codeflash_output = tx.requires_keystore() # 1.62μs -> 807ns (100% faster)

def test_requires_keystore_input_with_make_witness_as_non_callable():
    # Input has 'make_witness' as a non-callable attribute
    class InputWithWitnessAttr:
        make_witness = "witness"
    tx = PartialTransaction()
    tx._inputs = [InputWithWitnessAttr()]
    codeflash_output = tx.requires_keystore() # 1.49μs -> 687ns (117% faster)

def test_requires_keystore_input_with_make_witness_none():
    # Input has 'make_witness' set to None
    class InputWithWitnessNone:
        make_witness = None
    tx = PartialTransaction()
    tx._inputs = [InputWithWitnessNone()]
    codeflash_output = tx.requires_keystore() # 1.42μs -> 693ns (105% faster)

def test_requires_keystore_input_is_none():
    # Input is None (should not have make_witness)
    tx = PartialTransaction()
    tx._inputs = [None]
    codeflash_output = tx.requires_keystore() # 1.51μs -> 657ns (130% faster)

def test_requires_keystore_input_is_int():
    # Input is an integer (should not have make_witness)
    tx = PartialTransaction()
    tx._inputs = [42]
    codeflash_output = tx.requires_keystore() # 1.50μs -> 624ns (140% faster)

def test_requires_keystore_input_is_str():
    # Input is a string (should not have make_witness)
    tx = PartialTransaction()
    tx._inputs = ["input"]
    codeflash_output = tx.requires_keystore() # 1.45μs -> 633ns (129% faster)

def test_requires_keystore_input_is_dict_with_make_witness_key():
    # Input is a dict with 'make_witness' key, but not an attribute
    tx = PartialTransaction()
    tx._inputs = [{"make_witness": "witness"}]
    codeflash_output = tx.requires_keystore() # 1.63μs -> 608ns (168% faster)

def test_requires_keystore_input_is_object_with_dynamic_attr():
    # Input is object, 'make_witness' dynamically added
    class DynamicInput:
        pass
    inp = DynamicInput()
    setattr(inp, 'make_witness', lambda: "witness")
    tx = PartialTransaction()
    tx._inputs = [inp]
    codeflash_output = tx.requires_keystore() # 1.47μs -> 654ns (125% faster)

# Large Scale Test Cases

def test_requires_keystore_large_all_have_make_witness():
    # Large number of inputs, all have 'make_witness'
    tx = PartialTransaction()
    tx._inputs = [PartialTxInputWithWitness() for _ in range(1000)]
    codeflash_output = tx.requires_keystore() # 46.6μs -> 35.3μs (31.9% faster)

def test_requires_keystore_large_none_have_make_witness():
    # Large number of inputs, none have 'make_witness'
    tx = PartialTransaction()
    tx._inputs = [PartialTxInput() for _ in range(1000)]
    codeflash_output = tx.requires_keystore() # 1.55μs -> 667ns (132% faster)

def test_requires_keystore_large_one_missing_make_witness():
    # Large number of inputs, only one missing 'make_witness'
    tx = PartialTransaction()
    tx._inputs = [PartialTxInputWithWitness() for _ in range(999)] + [PartialTxInput()]
    codeflash_output = tx.requires_keystore() # 46.5μs -> 35.3μs (31.6% faster)

def test_requires_keystore_large_one_has_make_witness():
    # Large number of inputs, only one has 'make_witness'
    tx = PartialTransaction()
    tx._inputs = [PartialTxInput() for _ in range(999)] + [PartialTxInputWithWitness()]
    codeflash_output = tx.requires_keystore() # 1.60μs -> 677ns (136% faster)

def test_requires_keystore_large_mixed_types():
    # Large number of mixed types, half with 'make_witness', half without
    tx = PartialTransaction()
    tx._inputs = [PartialTxInputWithWitness() if i % 2 == 0 else PartialTxInput() for i in range(1000)]
    codeflash_output = tx.requires_keystore() # 1.76μs -> 807ns (118% faster)

def test_requires_keystore_performance_large_all_have_make_witness():
    # Performance: ensure large input does not slow down
    import time
    tx = PartialTransaction()
    tx._inputs = [PartialTxInputWithWitness() for _ in range(1000)]
    start = time.time()
    codeflash_output = tx.requires_keystore(); result = codeflash_output # 46.1μs -> 35.2μs (30.9% faster)
    duration = time.time() - start

def test_requires_keystore_performance_large_none_have_make_witness():
    # Performance: ensure large input does not slow down
    import time
    tx = PartialTransaction()
    tx._inputs = [PartialTxInput() for _ in range(1000)]
    start = time.time()
    codeflash_output = tx.requires_keystore(); result = codeflash_output # 1.59μs -> 638ns (149% faster)
    duration = time.time() - start
# 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 Sequence

# imports
import pytest
from electrum.transaction import PartialTransaction


class PartialTxInput:
    """Stub class for PartialTxInput used in PartialTransaction._inputs"""
    pass

class PartialTxInputWithWitness(PartialTxInput):
    """PartialTxInput subclass with make_witness attribute."""
    def make_witness(self):
        pass

# -------------------------------
# Unit tests for requires_keystore
# -------------------------------

# BASIC TEST CASES

def test_requires_keystore_empty_inputs():
    # Test with no inputs: should return False (no keystore required)
    pt = PartialTransaction()
    pt._inputs = []
    codeflash_output = pt.requires_keystore() # 1.35μs -> 530ns (155% faster)

def test_requires_keystore_all_inputs_have_make_witness():
    # All inputs have make_witness: should return False
    pt = PartialTransaction()
    pt._inputs = [PartialTxInputWithWitness(), PartialTxInputWithWitness()]
    codeflash_output = pt.requires_keystore() # 1.56μs -> 763ns (104% faster)

def test_requires_keystore_some_inputs_missing_make_witness():
    # Some inputs missing make_witness: should return True
    pt = PartialTransaction()
    pt._inputs = [PartialTxInputWithWitness(), PartialTxInput()]
    codeflash_output = pt.requires_keystore() # 1.82μs -> 796ns (129% faster)

def test_requires_keystore_all_inputs_missing_make_witness():
    # All inputs missing make_witness: should return True
    pt = PartialTransaction()
    pt._inputs = [PartialTxInput(), PartialTxInput()]
    codeflash_output = pt.requires_keystore() # 1.52μs -> 664ns (129% faster)

# EDGE TEST CASES

def test_requires_keystore_single_input_with_make_witness():
    # Single input with make_witness: should return False
    pt = PartialTransaction()
    pt._inputs = [PartialTxInputWithWitness()]
    codeflash_output = pt.requires_keystore() # 1.51μs -> 683ns (120% faster)

def test_requires_keystore_single_input_without_make_witness():
    # Single input without make_witness: should return True
    pt = PartialTransaction()
    pt._inputs = [PartialTxInput()]
    codeflash_output = pt.requires_keystore() # 1.51μs -> 660ns (129% faster)

def test_requires_keystore_input_with_make_witness_as_property():
    # Input with make_witness as a property (not a method): should still count
    class InputWithWitnessProp(PartialTxInput):
        @property
        def make_witness(self):
            return True
    pt = PartialTransaction()
    pt._inputs = [InputWithWitnessProp()]
    codeflash_output = pt.requires_keystore() # 1.58μs -> 896ns (76.8% faster)

def test_requires_keystore_input_with_make_witness_set_to_none():
    # Input with make_witness attribute set to None: should still count
    class InputWithWitnessNone(PartialTxInput):
        make_witness = None
    pt = PartialTransaction()
    pt._inputs = [InputWithWitnessNone()]
    codeflash_output = pt.requires_keystore() # 1.52μs -> 743ns (105% faster)

def test_requires_keystore_input_with_make_witness_as_non_callable():
    # Input with make_witness attribute as non-callable: should still count
    class InputWithWitnessNonCallable(PartialTxInput):
        make_witness = 42
    pt = PartialTransaction()
    pt._inputs = [InputWithWitnessNonCallable()]
    codeflash_output = pt.requires_keystore() # 1.48μs -> 747ns (97.7% faster)


def test_requires_keystore_input_with_make_witness_private():
    # Input with _make_witness (private): should NOT count
    class InputWithPrivateWitness(PartialTxInput):
        def _make_witness(self):
            pass
    pt = PartialTransaction()
    pt._inputs = [InputWithPrivateWitness()]
    codeflash_output = pt.requires_keystore() # 2.33μs -> 993ns (135% faster)

def test_requires_keystore_input_with_make_witness_case_sensitive():
    # Input with Make_Witness (wrong case): should NOT count
    class InputWithWrongCaseWitness(PartialTxInput):
        def Make_Witness(self):
            pass
    pt = PartialTransaction()
    pt._inputs = [InputWithWrongCaseWitness()]
    codeflash_output = pt.requires_keystore() # 1.84μs -> 831ns (121% faster)

def test_requires_keystore_input_with_make_witness_dynamic_add():
    # Input with make_witness dynamically added after creation: should count
    inp = PartialTxInput()
    inp.make_witness = lambda: True
    pt = PartialTransaction()
    pt._inputs = [inp]
    codeflash_output = pt.requires_keystore() # 1.57μs -> 684ns (130% faster)

# LARGE SCALE TEST CASES

def test_requires_keystore_large_all_have_make_witness():
    # Large number of inputs, all have make_witness: should return False
    pt = PartialTransaction()
    pt._inputs = [PartialTxInputWithWitness() for _ in range(1000)]
    codeflash_output = pt.requires_keystore() # 46.1μs -> 35.4μs (30.5% faster)

def test_requires_keystore_large_one_missing_make_witness():
    # Large number of inputs, one missing make_witness: should return True
    pt = PartialTransaction()
    pt._inputs = [PartialTxInputWithWitness() for _ in range(999)] + [PartialTxInput()]
    codeflash_output = pt.requires_keystore() # 46.1μs -> 35.3μs (30.5% faster)

def test_requires_keystore_large_all_missing_make_witness():
    # Large number of inputs, all missing make_witness: should return True
    pt = PartialTransaction()
    pt._inputs = [PartialTxInput() for _ in range(1000)]
    codeflash_output = pt.requires_keystore() # 1.54μs -> 663ns (133% faster)

def test_requires_keystore_large_first_missing_make_witness():
    # Large number of inputs, first missing make_witness: should return True
    pt = PartialTransaction()
    pt._inputs = [PartialTxInput()] + [PartialTxInputWithWitness() for _ in range(999)]
    codeflash_output = pt.requires_keystore() # 1.50μs -> 631ns (137% faster)

def test_requires_keystore_large_last_missing_make_witness():
    # Large number of inputs, last missing make_witness: should return True
    pt = PartialTransaction()
    pt._inputs = [PartialTxInputWithWitness() for _ in range(999)] + [PartialTxInput()]
    codeflash_output = pt.requires_keystore() # 45.8μs -> 35.1μs (30.5% faster)

# Additional edge: inputs with mixed types and attributes
def test_requires_keystore_mixed_inputs():
    class InputWithWitnessAsString(PartialTxInput):
        make_witness = "not callable but present"
    pt = PartialTransaction()
    pt._inputs = [
        PartialTxInputWithWitness(),
        PartialTxInput(),
        InputWithWitnessAsString(),
        PartialTxInputWithWitness()
    ]
    # One input missing make_witness
    codeflash_output = pt.requires_keystore() # 1.73μs -> 756ns (129% faster)

def test_requires_keystore_all_inputs_have_make_witness_various_types():
    class InputWithWitnessAsString(PartialTxInput):
        make_witness = "present"
    class InputWithWitnessAsProperty(PartialTxInput):
        @property
        def make_witness(self):
            return True
    pt = PartialTransaction()
    pt._inputs = [
        PartialTxInputWithWitness(),
        InputWithWitnessAsString(),
        InputWithWitnessAsProperty(),
        PartialTxInputWithWitness()
    ]
    # All inputs have make_witness attribute
    codeflash_output = pt.requires_keystore() # 2.13μs -> 1.34μs (59.2% faster)
# 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 PartialTransaction

def test_PartialTransaction_requires_keystore():
    PartialTransaction.requires_keystore(PartialTransaction())

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_0kz7t2kd/tmpqebpeoj_/test_concolic_coverage.py::test_PartialTransaction_requires_keystore	1.22μs	491ns	149%✅

To edit these changes git checkout codeflash/optimize-PartialTransaction.requires_keystore-mhoplso6 and push.