⚡️ Speed up method SwapData.is_funded by 11%

[codeflash-ai]

📄 11% (0.11x) speedup for SwapData.is_funded in electrum/submarine_swaps.py

⏱️ Runtime : 708 microseconds → 641 microseconds (best of 171 runs)

📝 Explanation and details

The optimization reorders the boolean expression in the is_funded method from self._payment_pending or bool(self.funding_txid) to bool(self.funding_txid) or self._payment_pending. This simple change achieves a 10% speedup by taking advantage of Python's short-circuit evaluation.

Key optimization: When funding_txid is truthy (non-None, non-empty string), the optimized version can return True immediately without evaluating _payment_pending. The bool() function call is faster than accessing the _payment_pending attribute.

Why this works: The test results show this optimization performs best when funding_txid is set and _payment_pending is False (18.6% faster in one test case). This suggests that in typical usage, funding_txid being truthy is more common than _payment_pending being True, making the reordering beneficial for the common case.

Trade-off: The optimization is slightly slower (6-28%) when _payment_pending is True but funding_txid is falsy, since it must evaluate the more expensive bool(self.funding_txid) first. However, the overall 10% speedup indicates this is a less frequent scenario.

This optimization is most effective for workloads where funded swaps (with valid funding transaction IDs) are processed frequently, as demonstrated by the large batch tests showing 25.8% improvement when all swaps have funding_txid set.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Optional

# function to test
import attr
# imports
import pytest  # used for our unit tests
from electrum.submarine_swaps import SwapData


# Dummy hex_to_bytes function for testing (since electrum.lnutil.hex_to_bytes is unavailable)
def hex_to_bytes(s):
    if s is None:
        return None
    if isinstance(s, bytes):
        return s
    return bytes.fromhex(s)
from electrum.submarine_swaps import SwapData

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

# Basic Test Cases

def test_is_funded_with_funding_txid_only():
    """Should return True when funding_txid is set (non-empty string) and _payment_pending is False."""
    swap = SwapData(
        is_reverse=False, locktime=0, onchain_amount=1000, lightning_amount=1000,
        redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
        lockup_address="addr1", receive_address="addr2",
        funding_txid="abcd1234", spending_txid=None, is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 549ns -> 463ns (18.6% faster)

def test_is_funded_with_payment_pending_only():
    """Should return True when _payment_pending is True and funding_txid is None."""
    swap = SwapData(
        is_reverse=True, locktime=0, onchain_amount=500, lightning_amount=500,
        redeem_script=b'01', preimage=None, prepay_hash=None, privkey=b'01',
        lockup_address="addr3", receive_address="addr4",
        funding_txid=None, spending_txid=None, is_redeemed=False
    )
    swap._payment_pending = True
    codeflash_output = swap.is_funded() # 389ns -> 509ns (23.6% slower)

def test_is_funded_with_both_funding_txid_and_payment_pending():
    """Should return True when both _payment_pending is True and funding_txid is set."""
    swap = SwapData(
        is_reverse=True, locktime=0, onchain_amount=500, lightning_amount=500,
        redeem_script=b'01', preimage=None, prepay_hash=None, privkey=b'01',
        lockup_address="addr3", receive_address="addr4",
        funding_txid="abcd1234", spending_txid=None, is_redeemed=False
    )
    swap._payment_pending = True
    codeflash_output = swap.is_funded() # 375ns -> 420ns (10.7% slower)

def test_is_funded_with_neither_funding_txid_nor_payment_pending():
    """Should return False when both _payment_pending is False and funding_txid is None."""
    swap = SwapData(
        is_reverse=False, locktime=0, onchain_amount=1000, lightning_amount=1000,
        redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
        lockup_address="addr1", receive_address="addr2",
        funding_txid=None, spending_txid=None, is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 444ns -> 473ns (6.13% slower)

# Edge Test Cases

def test_is_funded_with_empty_funding_txid_string():
    """Should return False when funding_txid is empty string and _payment_pending is False."""
    swap = SwapData(
        is_reverse=False, locktime=0, onchain_amount=1000, lightning_amount=1000,
        redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
        lockup_address="addr1", receive_address="addr2",
        funding_txid="", spending_txid=None, is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 447ns -> 488ns (8.40% slower)

def test_is_funded_with_whitespace_funding_txid():
    """Should return True when funding_txid is whitespace (non-empty string), _payment_pending is False."""
    swap = SwapData(
        is_reverse=False, locktime=0, onchain_amount=1000, lightning_amount=1000,
        redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
        lockup_address="addr1", receive_address="addr2",
        funding_txid=" ", spending_txid=None, is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 432ns -> 383ns (12.8% faster)

def test_is_funded_with_funding_txid_falsey_types():
    """Should return False for funding_txid set to False, 0, or other falsey types and _payment_pending False."""
    for falsey in [None, "", 0, False]:
        swap = SwapData(
            is_reverse=False, locktime=0, onchain_amount=1000, lightning_amount=1000,
            redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
            lockup_address="addr1", receive_address="addr2",
            funding_txid=falsey, spending_txid=None, is_redeemed=False
        )
        swap._payment_pending = False
        codeflash_output = swap.is_funded() # 1.13μs -> 1.24μs (9.00% slower)

def test_is_funded_with_funding_txid_true_types():
    """Should return True for funding_txid set to non-empty string, int, True, etc."""
    for truthy in ["abc", "0", 1, True]:
        swap = SwapData(
            is_reverse=False, locktime=0, onchain_amount=1000, lightning_amount=1000,
            redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
            lockup_address="addr1", receive_address="addr2",
            funding_txid=truthy, spending_txid=None, is_redeemed=False
        )
        swap._payment_pending = False
        codeflash_output = swap.is_funded() # 1.06μs -> 1.05μs (1.33% faster)

def test_is_funded_with_payment_pending_and_falsey_funding_txid():
    """Should return True when _payment_pending is True even if funding_txid is falsey."""
    for falsey in [None, "", 0, False]:
        swap = SwapData(
            is_reverse=True, locktime=0, onchain_amount=1000, lightning_amount=1000,
            redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
            lockup_address="addr1", receive_address="addr2",
            funding_txid=falsey, spending_txid=None, is_redeemed=False
        )
        swap._payment_pending = True
        codeflash_output = swap.is_funded() # 780ns -> 1.09μs (28.4% slower)

def test_is_funded_with_payment_pending_false_and_funding_txid_falsey():
    """Should return False when both _payment_pending and funding_txid are falsey."""
    for falsey in [None, "", 0, False]:
        swap = SwapData(
            is_reverse=True, locktime=0, onchain_amount=1000, lightning_amount=1000,
            redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
            lockup_address="addr1", receive_address="addr2",
            funding_txid=falsey, spending_txid=None, is_redeemed=False
        )
        swap._payment_pending = False
        codeflash_output = swap.is_funded() # 1.00μs -> 1.13μs (10.8% slower)

def test_is_funded_with_various_types_for_funding_txid():
    """Should handle various types for funding_txid robustly."""
    # Should be True for non-empty string, non-zero int, True
    for val in ["funded", 42, True]:
        swap = SwapData(
            is_reverse=False, locktime=0, onchain_amount=1000, lightning_amount=1000,
            redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
            lockup_address="addr1", receive_address="addr2",
            funding_txid=val, spending_txid=None, is_redeemed=False
        )
        swap._payment_pending = False
        codeflash_output = swap.is_funded() # 847ns -> 796ns (6.41% faster)
    # Should be False for None, "", 0, False
    for val in [None, "", 0, False]:
        swap = SwapData(
            is_reverse=False, locktime=0, onchain_amount=1000, lightning_amount=1000,
            redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
            lockup_address="addr1", receive_address="addr2",
            funding_txid=val, spending_txid=None, is_redeemed=False
        )
        swap._payment_pending = False
        codeflash_output = swap.is_funded() # 755ns -> 882ns (14.4% slower)

def test_is_funded_with_mutable_funding_txid():
    """Should reflect changes to funding_txid after object creation."""
    swap = SwapData(
        is_reverse=False, locktime=0, onchain_amount=1000, lightning_amount=1000,
        redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
        lockup_address="addr1", receive_address="addr2",
        funding_txid=None, spending_txid=None, is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 375ns -> 377ns (0.531% slower)
    swap.funding_txid = "newtxid"
    codeflash_output = swap.is_funded() # 254ns -> 275ns (7.64% slower)
    swap.funding_txid = ""
    codeflash_output = swap.is_funded() # 198ns -> 228ns (13.2% slower)

def test_is_funded_with_mutable_payment_pending():
    """Should reflect changes to _payment_pending after object creation."""
    swap = SwapData(
        is_reverse=False, locktime=0, onchain_amount=1000, lightning_amount=1000,
        redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
        lockup_address="addr1", receive_address="addr2",
        funding_txid=None, spending_txid=None, is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 357ns -> 396ns (9.85% slower)
    swap._payment_pending = True
    codeflash_output = swap.is_funded() # 245ns -> 235ns (4.26% faster)

# Large Scale Test Cases

def test_is_funded_large_batch_all_funded():
    """Should return True for all swaps in a large batch where funding_txid is set."""
    swaps = []
    for i in range(1000):
        swap = SwapData(
            is_reverse=False, locktime=i, onchain_amount=1000+i, lightning_amount=1000+i,
            redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
            lockup_address="addr1", receive_address="addr2",
            funding_txid=f"txid{i}", spending_txid=None, is_redeemed=False
        )
        swap._payment_pending = False
        swaps.append(swap)
    # All should be funded
    for swap in swaps:
        codeflash_output = swap.is_funded() # 179μs -> 142μs (25.8% faster)

def test_is_funded_large_batch_none_funded():
    """Should return False for all swaps in a large batch where neither funding_txid nor _payment_pending is set."""
    swaps = []
    for i in range(1000):
        swap = SwapData(
            is_reverse=True, locktime=i, onchain_amount=1000+i, lightning_amount=1000+i,
            redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
            lockup_address="addr1", receive_address="addr2",
            funding_txid=None, spending_txid=None, is_redeemed=False
        )
        swap._payment_pending = False
        swaps.append(swap)
    # None should be funded
    for swap in swaps:
        codeflash_output = swap.is_funded() # 176μs -> 164μs (7.59% faster)


def test_is_funded_large_batch_mutation():
    """Should reflect changes to funding_txid and _payment_pending in a large batch."""
    swaps = []
    for i in range(1000):
        swap = SwapData(
            is_reverse=False, locktime=i, onchain_amount=1000+i, lightning_amount=1000+i,
            redeem_script=b'00', preimage=None, prepay_hash=None, privkey=b'00',
            lockup_address="addr1", receive_address="addr2",
            funding_txid=None, spending_txid=None, is_redeemed=False
        )
        swap._payment_pending = False
        swaps.append(swap)
    # Set funding_txid for half, _payment_pending for other half
    for i, swap in enumerate(swaps):
        if i < 500:
            swap.funding_txid = f"txid{i}"
        else:
            swap._payment_pending = True
    for i, swap in enumerate(swaps):
        codeflash_output = swap.is_funded() # 158μs -> 150μs (5.12% faster)
# 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 Optional

# function to test
import attr
# imports
import pytest
from electrum.submarine_swaps import SwapData

# unit tests

# ----------------------
# Basic Test Cases
# ----------------------

def test_is_funded_with_payment_pending_true():
    """Should return True when _payment_pending is True, regardless of funding_txid."""
    swap = SwapData(
        is_reverse=False,
        locktime=1000,
        onchain_amount=50000,
        lightning_amount=50000,
        redeem_script=b'abc',
        preimage=None,
        prepay_hash=None,
        privkey=b'def',
        lockup_address='address1',
        receive_address='address2',
        funding_txid=None,
        spending_txid=None,
        is_redeemed=False
    )
    swap._payment_pending = True
    swap.funding_txid = None
    codeflash_output = swap.is_funded() # 368ns -> 493ns (25.4% slower)

def test_is_funded_with_valid_funding_txid():
    """Should return True when funding_txid is a non-empty string, regardless of _payment_pending."""
    swap = SwapData(
        is_reverse=False,
        locktime=1000,
        onchain_amount=50000,
        lightning_amount=50000,
        redeem_script=b'abc',
        preimage=None,
        prepay_hash=None,
        privkey=b'def',
        lockup_address='address1',
        receive_address='address2',
        funding_txid='deadbeef',
        spending_txid=None,
        is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 373ns -> 376ns (0.798% slower)

def test_is_funded_with_payment_pending_false_and_funding_txid_none():
    """Should return False when both _payment_pending is False and funding_txid is None."""
    swap = SwapData(
        is_reverse=True,
        locktime=1000,
        onchain_amount=100000,
        lightning_amount=100000,
        redeem_script=b'xyz',
        preimage=None,
        prepay_hash=None,
        privkey=b'ghi',
        lockup_address='address3',
        receive_address='address4',
        funding_txid=None,
        spending_txid=None,
        is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 421ns -> 443ns (4.97% slower)

# ----------------------
# Edge Test Cases
# ----------------------

def test_is_funded_with_funding_txid_empty_string():
    """Should return False if funding_txid is an empty string and _payment_pending is False."""
    swap = SwapData(
        is_reverse=False,
        locktime=0,
        onchain_amount=0,
        lightning_amount=0,
        redeem_script=b'',
        preimage=None,
        prepay_hash=None,
        privkey=b'',
        lockup_address='',
        receive_address='',
        funding_txid='',
        spending_txid=None,
        is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 422ns -> 467ns (9.64% slower)

def test_is_funded_with_funding_txid_whitespace_string():
    """Should return True if funding_txid is a whitespace string (non-empty, thus truthy)."""
    swap = SwapData(
        is_reverse=False,
        locktime=0,
        onchain_amount=0,
        lightning_amount=0,
        redeem_script=b'',
        preimage=None,
        prepay_hash=None,
        privkey=b'',
        lockup_address='',
        receive_address='',
        funding_txid=' ',
        spending_txid=None,
        is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 424ns -> 420ns (0.952% faster)

def test_is_funded_with_funding_txid_zero_string():
    """Should return True if funding_txid is '0' (non-empty string)."""
    swap = SwapData(
        is_reverse=False,
        locktime=0,
        onchain_amount=0,
        lightning_amount=0,
        redeem_script=b'',
        preimage=None,
        prepay_hash=None,
        privkey=b'',
        lockup_address='',
        receive_address='',
        funding_txid='0',
        spending_txid=None,
        is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 404ns -> 360ns (12.2% faster)

def test_is_funded_with_funding_txid_false_and_payment_pending_true():
    """Should return True if _payment_pending is True even if funding_txid is False-like value."""
    swap = SwapData(
        is_reverse=False,
        locktime=0,
        onchain_amount=0,
        lightning_amount=0,
        redeem_script=b'',
        preimage=None,
        prepay_hash=None,
        privkey=b'',
        lockup_address='',
        receive_address='',
        funding_txid='',
        spending_txid=None,
        is_redeemed=False
    )
    swap._payment_pending = True
    codeflash_output = swap.is_funded() # 335ns -> 448ns (25.2% slower)

def test_is_funded_with_funding_txid_none_and_payment_pending_true():
    """Should return True if _payment_pending is True even if funding_txid is None."""
    swap = SwapData(
        is_reverse=False,
        locktime=0,
        onchain_amount=0,
        lightning_amount=0,
        redeem_script=b'',
        preimage=None,
        prepay_hash=None,
        privkey=b'',
        lockup_address='',
        receive_address='',
        funding_txid=None,
        spending_txid=None,
        is_redeemed=False
    )
    swap._payment_pending = True
    codeflash_output = swap.is_funded() # 343ns -> 446ns (23.1% slower)

def test_is_funded_with_funding_txid_boolean_false():
    """Should return False if funding_txid is boolean False and _payment_pending is False."""
    swap = SwapData(
        is_reverse=False,
        locktime=0,
        onchain_amount=0,
        lightning_amount=0,
        redeem_script=b'',
        preimage=None,
        prepay_hash=None,
        privkey=b'',
        lockup_address='',
        receive_address='',
        funding_txid=False,
        spending_txid=None,
        is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 420ns -> 462ns (9.09% slower)

def test_is_funded_with_funding_txid_boolean_true():
    """Should return True if funding_txid is boolean True and _payment_pending is False."""
    swap = SwapData(
        is_reverse=False,
        locktime=0,
        onchain_amount=0,
        lightning_amount=0,
        redeem_script=b'',
        preimage=None,
        prepay_hash=None,
        privkey=b'',
        lockup_address='',
        receive_address='',
        funding_txid=True,
        spending_txid=None,
        is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 425ns -> 406ns (4.68% faster)

def test_is_funded_with_funding_txid_integer():
    """Should return True if funding_txid is a non-zero integer (truthy)."""
    swap = SwapData(
        is_reverse=False,
        locktime=0,
        onchain_amount=0,
        lightning_amount=0,
        redeem_script=b'',
        preimage=None,
        prepay_hash=None,
        privkey=b'',
        lockup_address='',
        receive_address='',
        funding_txid=12345,
        spending_txid=None,
        is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 424ns -> 391ns (8.44% faster)

def test_is_funded_with_funding_txid_zero_integer():
    """Should return False if funding_txid is zero integer (falsy) and _payment_pending is False."""
    swap = SwapData(
        is_reverse=False,
        locktime=0,
        onchain_amount=0,
        lightning_amount=0,
        redeem_script=b'',
        preimage=None,
        prepay_hash=None,
        privkey=b'',
        lockup_address='',
        receive_address='',
        funding_txid=0,
        spending_txid=None,
        is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 410ns -> 439ns (6.61% slower)

def test_is_funded_with_funding_txid_list():
    """Should return True if funding_txid is a non-empty list (truthy)."""
    swap = SwapData(
        is_reverse=False,
        locktime=0,
        onchain_amount=0,
        lightning_amount=0,
        redeem_script=b'',
        preimage=None,
        prepay_hash=None,
        privkey=b'',
        lockup_address='',
        receive_address='',
        funding_txid=['txid'],
        spending_txid=None,
        is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 434ns -> 393ns (10.4% faster)

def test_is_funded_with_funding_txid_empty_list():
    """Should return False if funding_txid is an empty list (falsy) and _payment_pending is False."""
    swap = SwapData(
        is_reverse=False,
        locktime=0,
        onchain_amount=0,
        lightning_amount=0,
        redeem_script=b'',
        preimage=None,
        prepay_hash=None,
        privkey=b'',
        lockup_address='',
        receive_address='',
        funding_txid=[],
        spending_txid=None,
        is_redeemed=False
    )
    swap._payment_pending = False
    codeflash_output = swap.is_funded() # 433ns -> 473ns (8.46% slower)

# ----------------------
# Large Scale Test Cases
# ----------------------

def test_is_funded_large_batch_all_pending():
    """Should return True for all swaps when _payment_pending is True in a large batch."""
    swaps = []
    for i in range(1000):
        swap = SwapData(
            is_reverse=False,
            locktime=i,
            onchain_amount=i * 100,
            lightning_amount=i * 100,
            redeem_script=b'abc',
            preimage=None,
            prepay_hash=None,
            privkey=b'def',
            lockup_address=f'address{i}',
            receive_address=f'address{i+1}',
            funding_txid=None,
            spending_txid=None,
            is_redeemed=False
        )
        swap._payment_pending = True
        swaps.append(swap)

def test_is_funded_large_batch_all_funding_txid():
    """Should return True for all swaps when funding_txid is non-empty in a large batch."""
    swaps = []
    for i in range(1000):
        swap = SwapData(
            is_reverse=False,
            locktime=i,
            onchain_amount=i * 100,
            lightning_amount=i * 100,
            redeem_script=b'abc',
            preimage=None,
            prepay_hash=None,
            privkey=b'def',
            lockup_address=f'address{i}',
            receive_address=f'address{i+1}',
            funding_txid=f'txid_{i}',
            spending_txid=None,
            is_redeemed=False
        )
        swap._payment_pending = False
        swaps.append(swap)

def test_is_funded_large_batch_none_funded():
    """Should return False for all swaps when neither _payment_pending nor funding_txid is truthy in a large batch."""
    swaps = []
    for i in range(1000):
        swap = SwapData(
            is_reverse=False,
            locktime=i,
            onchain_amount=i * 100,
            lightning_amount=i * 100,
            redeem_script=b'abc',
            preimage=None,
            prepay_hash=None,
            privkey=b'def',
            lockup_address=f'address{i}',
            receive_address=f'address{i+1}',
            funding_txid=None,
            spending_txid=None,
            is_redeemed=False
        )
        swap._payment_pending = False
        swaps.append(swap)


#------------------------------------------------
from electrum.submarine_swaps import SwapData

def test_SwapData_is_funded():
    SwapData.is_funded(SwapData(False, 0, 0, 0, None, '', '', '', '', '', '', '', True))

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic__q13nwva/tmpurhc1cva/test_concolic_coverage.py::test_SwapData_is_funded	567ns	597ns	-5.03%⚠️

To edit these changes git checkout codeflash/optimize-SwapData.is_funded-mhjidh8f and push.