⚡️ Speed up function create_bip21_uri by 11%

[codeflash-ai]

📄 11% (0.11x) speedup for create_bip21_uri in electrum/bip21.py

⏱️ Runtime : 2.10 milliseconds → 1.88 milliseconds (best of 250 runs)

📝 Explanation and details

The optimization achieves an 11% speedup by eliminating the expensive urllib.parse.ParseResult construction and urlunparse() call, which together accounted for about 7% of the original function's runtime according to the line profiler.

Key optimizations:

1. Eliminated ParseResult and urlunparse(): Instead of constructing a ParseResult object and calling urlunparse(), the code directly builds the URI string using f-strings. This removes object allocation overhead and the complex URL reconstruction logic.

2. Cached urllib.parse.quote lookup: By assigning quote = urllib.parse.quote once, the code avoids repeated module attribute lookups in the loop processing extra query parameters.

3. Direct string concatenation: The optimized version builds the final URI directly with conditional logic - f"{BITCOIN_BIP21_URI_SCHEME}:{addr}?{query_str}" when there are query parameters, or f"{BITCOIN_BIP21_URI_SCHEME}:{addr}" when there aren't.

4. Eliminated redundant variable assignment: Removed the intermediate v = urllib.parse.quote(v) step, directly using quote(v) in the f-string.

Performance impact by test case:

• Best gains (20-30% faster): Cases with no query parameters or simple parameters benefit most from avoiding the ParseResult/urlunparse overhead
• Minimal impact (0-2% slower): Complex cases with many parameters see less benefit since the loop processing dominates runtime
• Large-scale cases: Still show 10-15% improvements, indicating the optimization scales well

The function is called from get_bip21_URI() in the invoices module, which handles payment URI generation. Since this appears to be in a payment processing path, even an 11% improvement in URI generation can meaningfully impact user experience during payment flows.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import urllib
from typing import Optional

# imports
import pytest
from electrum.bip21 import create_bip21_uri

BITCOIN_BIP21_URI_SCHEME = 'bitcoin'
from electrum.bip21 import create_bip21_uri

# unit tests

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

def test_basic_address_only():
    # Should return a valid bip21 URI with only the address
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    codeflash_output = create_bip21_uri(addr, None, None); uri = codeflash_output # 19.4μs -> 15.3μs (27.4% faster)

def test_basic_with_amount():
    # Should return URI with address and amount
    addr = "3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy"
    amount_sat = 123456789
    codeflash_output = create_bip21_uri(addr, amount_sat, None); uri = codeflash_output # 24.7μs -> 20.2μs (22.3% faster)

def test_basic_with_message():
    # Should return URI with address and message (properly url-encoded)
    addr = "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
    message = "Donation for project"
    codeflash_output = create_bip21_uri(addr, None, message); uri = codeflash_output # 36.3μs -> 35.8μs (1.53% faster)

def test_basic_with_amount_and_message():
    # Should return URI with address, amount, and message
    addr = "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
    amount_sat = 100000000
    message = "Thanks!"
    codeflash_output = create_bip21_uri(addr, amount_sat, message); uri = codeflash_output # 32.9μs -> 33.6μs (2.10% slower)

def test_basic_with_extra_query_params():
    # Should append extra query params, url-encoded
    addr = "1BoatSLRHtKNngkdXEeobR76b53LETtpyT"
    params = {"label": "Coffee Shop", "foo": "bar baz"}
    codeflash_output = create_bip21_uri(addr, None, None, extra_query_params=params); uri = codeflash_output # 27.9μs -> 23.5μs (18.8% faster)

def test_basic_with_all_fields():
    # Should include address, amount, message, and extra params
    addr = "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
    amount_sat = 50000000
    message = "Lunch payment"
    params = {"label": "Alice", "purpose": "lunch"}
    codeflash_output = create_bip21_uri(addr, amount_sat, message, extra_query_params=params); uri = codeflash_output # 34.8μs -> 35.0μs (0.674% slower)

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

def test_invalid_address_returns_empty():
    # Should return empty string for invalid address
    codeflash_output = create_bip21_uri("not_a_valid_address", 1000, "msg") # 7.32μs -> 7.49μs (2.23% slower)

def test_none_address_returns_empty():
    # Should return empty string for None address
    codeflash_output = create_bip21_uri(None, 1000, "msg") # 2.83μs -> 2.89μs (2.01% slower)

def test_empty_address_returns_empty():
    # Should return empty string for empty address
    codeflash_output = create_bip21_uri("", 1000, "msg") # 12.8μs -> 12.9μs (1.25% slower)

def test_zero_amount_omitted():
    # Should not include amount=0 in the URI
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    codeflash_output = create_bip21_uri(addr, 0, None); uri = codeflash_output # 19.1μs -> 14.5μs (32.3% faster)



def test_message_special_characters():
    # Should url-encode special characters in message
    addr = "1BoatSLRHtKNngkdXEeobR76b53LETtpyT"
    message = "Hello, world! 100% & more?"
    codeflash_output = create_bip21_uri(addr, None, message); uri = codeflash_output # 34.0μs -> 28.6μs (18.8% faster)

def test_extra_param_illegal_key_raises():
    # Should raise for illegal key (not url-safe)
    addr = "1BoatSLRHtKNngkdXEeobR76b53LETtpyT"
    params = {"bad key": "value"}
    with pytest.raises(Exception):
        create_bip21_uri(addr, None, None, extra_query_params=params) # 18.9μs -> 18.7μs (1.19% faster)

def test_extra_param_non_string_key_raises():
    # Should raise for non-string key
    addr = "1BoatSLRHtKNngkdXEeobR76b53LETtpyT"
    params = {123: "value"}
    with pytest.raises(Exception):
        create_bip21_uri(addr, None, None, extra_query_params=params) # 14.3μs -> 14.7μs (2.70% slower)

def test_extra_param_value_needs_encoding():
    # Should url-encode the value
    addr = "1BoatSLRHtKNngkdXEeobR76b53LETtpyT"
    params = {"label": "hello world!"}
    codeflash_output = create_bip21_uri(addr, None, None, extra_query_params=params); uri = codeflash_output # 23.7μs -> 18.7μs (26.7% faster)

def test_all_fields_with_special_chars():
    # All fields with special characters
    addr = "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
    amount_sat = 123456789
    message = "Payment for: lunch & coffee!"
    params = {"label": "Alice&Bob", "purpose": "lunch/coffee"}
    codeflash_output = create_bip21_uri(addr, amount_sat, message, extra_query_params=params); uri = codeflash_output # 38.6μs -> 38.7μs (0.328% slower)

def test_case_insensitive_address():
    # Bech32 addresses are case-insensitive
    addr = "BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KYGT080"
    codeflash_output = create_bip21_uri(addr, None, None); uri = codeflash_output # 34.9μs -> 34.9μs (0.094% slower)

def test_extra_query_params_none():
    # Should handle extra_query_params=None gracefully
    addr = "1BoatSLRHtKNngkdXEeobR76b53LETtpyT"
    codeflash_output = create_bip21_uri(addr, None, None, extra_query_params=None); uri = codeflash_output # 20.4μs -> 16.1μs (26.0% faster)

def test_message_empty_string():
    # Should not add message param if message is empty string
    addr = "1BoatSLRHtKNngkdXEeobR76b53LETtpyT"
    codeflash_output = create_bip21_uri(addr, None, ""); uri = codeflash_output # 17.3μs -> 13.6μs (26.8% faster)

def test_extra_query_param_empty_dict():
    # Should not add extra query params if dict is empty
    addr = "1BoatSLRHtKNngkdXEeobR76b53LETtpyT"
    codeflash_output = create_bip21_uri(addr, None, None, extra_query_params={}); uri = codeflash_output # 16.7μs -> 13.5μs (23.7% faster)

# -------------------------------
# LARGE SCALE TEST CASES
# -------------------------------

def test_large_number_of_query_params():
    # Should handle a large number of extra query params
    addr = "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
    params = {f"key{i}": f"value{i}" for i in range(1000)}
    codeflash_output = create_bip21_uri(addr, None, None, extra_query_params=params); uri = codeflash_output # 36.8μs -> 37.2μs (1.06% slower)

def test_large_message_length():
    # Should handle a very long message
    addr = "1BoatSLRHtKNngkdXEeobR76b53LETtpyT"
    message = "a" * 1000
    codeflash_output = create_bip21_uri(addr, None, message); uri = codeflash_output # 27.6μs -> 23.7μs (16.2% faster)

def test_large_amount():
    # Should handle very large amounts (up to 21 million BTC)
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    amount_sat = 21_000_000 * 100_000_000  # 21 million BTC in satoshis
    codeflash_output = create_bip21_uri(addr, amount_sat, None); uri = codeflash_output # 27.0μs -> 23.3μs (15.5% faster)

def test_performance_with_large_inputs():
    # Not a strict performance test, but checks function completes for large inputs
    addr = "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
    message = "test" * 250
    params = {f"k{i}": "v" for i in range(500)}
    codeflash_output = create_bip21_uri(addr, 999999999, message, extra_query_params=params); uri = codeflash_output # 35.8μs -> 36.2μs (1.10% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import urllib

# imports
import pytest
from electrum.bip21 import create_bip21_uri

# Patch the imports in the function
BITCOIN_BIP21_URI_SCHEME = 'bitcoin'
from electrum.bip21 import create_bip21_uri

# --- Unit tests ---
# Basic Test Cases

def test_basic_address_only():
    # Only address, no amount, no message, no extra params
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    codeflash_output = create_bip21_uri(addr, None, None); uri = codeflash_output # 22.8μs -> 18.5μs (23.1% faster)

def test_basic_address_and_amount():
    # Address and amount
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    codeflash_output = create_bip21_uri(addr, 100000000, None); uri = codeflash_output # 27.1μs -> 22.7μs (19.4% faster)

def test_basic_address_amount_message():
    # Address, amount, and message
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    codeflash_output = create_bip21_uri(addr, 250000000, "Donation"); uri = codeflash_output # 25.2μs -> 21.9μs (15.2% faster)

def test_basic_address_amount_message_extra():
    # Address, amount, message, and extra param
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    codeflash_output = create_bip21_uri(addr, 50000000, "Thanks!", extra_query_params={"label": "Alice"}); uri = codeflash_output # 27.7μs -> 23.9μs (15.9% faster)

def test_basic_segwit_address():
    # Segwit address
    addr = "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
    codeflash_output = create_bip21_uri(addr, None, None); uri = codeflash_output # 37.6μs -> 37.5μs (0.285% faster)

def test_basic_testnet_address():
    # Testnet address
    addr = "tb1qfm2k2k4j4s2q9v3n6w5v6z5v2j2k2k4j4s2q9v"
    codeflash_output = create_bip21_uri(addr, None, None); uri = codeflash_output # 41.7μs -> 41.9μs (0.594% slower)

# Edge Test Cases

def test_invalid_address_returns_empty():
    # Invalid address should return empty string
    addr = "not_a_real_address"
    codeflash_output = create_bip21_uri(addr, 100000000, "Invalid"); uri = codeflash_output # 7.56μs -> 7.79μs (2.99% slower)

def test_amount_zero():
    # Amount of zero: should not appear in URI
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    codeflash_output = create_bip21_uri(addr, 0, None); uri = codeflash_output # 19.2μs -> 14.4μs (33.1% faster)

def test_amount_none():
    # Amount None: should not appear in URI
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    codeflash_output = create_bip21_uri(addr, None, None); uri = codeflash_output # 16.9μs -> 13.5μs (25.5% faster)

def test_message_none_and_empty():
    # Message None: should not appear in URI
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    codeflash_output = create_bip21_uri(addr, 100000000, None); uri_none = codeflash_output # 24.8μs -> 21.1μs (17.4% faster)
    # Message empty: should not appear in URI
    codeflash_output = create_bip21_uri(addr, 100000000, ""); uri_empty = codeflash_output # 12.4μs -> 9.85μs (25.9% faster)

def test_message_special_characters():
    # Message with special characters should be percent-encoded
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    msg = "Donate now! & get 50% off."
    codeflash_output = create_bip21_uri(addr, 100000000, msg); uri = codeflash_output # 26.3μs -> 23.3μs (13.3% faster)
    expected = f"bitcoin:{addr}?amount=1&message={urllib.parse.quote(msg)}"

def test_extra_query_params_empty():
    # Extra query params empty dict: should not affect URI
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    codeflash_output = create_bip21_uri(addr, 100000000, None, extra_query_params={}); uri = codeflash_output # 21.8μs -> 17.7μs (23.1% faster)

def test_extra_query_params_non_string_key():
    # Non-string key should raise Exception
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    with pytest.raises(Exception):
        create_bip21_uri(addr, 100000000, None, extra_query_params={123: "value"}) # 17.8μs -> 17.8μs (0.045% slower)

def test_extra_query_params_illegal_key():
    # Key with illegal character (not url-quoted) should raise Exception
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    with pytest.raises(Exception):
        create_bip21_uri(addr, 100000000, None, extra_query_params={"bad key": "value"}) # 22.0μs -> 22.4μs (1.65% slower)

def test_extra_query_params_special_characters():
    # Value with special characters should be percent-encoded
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    extra = {"label": "Alice & Bob"}
    codeflash_output = create_bip21_uri(addr, 100000000, None, extra_query_params=extra); uri = codeflash_output # 26.8μs -> 22.7μs (18.4% faster)
    expected = f"bitcoin:{addr}?amount=1&label=Alice%20%26%20Bob"

def test_extra_query_params_multiple():
    # Multiple extra params
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    extra = {"label": "Alice", "note": "Payment for invoice #123"}
    # keys must be url-quoted (no spaces or special chars)
    codeflash_output = create_bip21_uri(addr, 100000000, None, extra_query_params=extra); uri = codeflash_output # 28.2μs -> 24.0μs (17.8% faster)
    expected = f"bitcoin:{addr}?amount=1&label=Alice&note=Payment%20for%20invoice%20%23123"

def test_extra_query_params_order():
    # Order of query params is preserved
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    extra = {"label": "Alice", "note": "Payment"}
    codeflash_output = create_bip21_uri(addr, 100000000, None, extra_query_params=extra); uri = codeflash_output # 25.0μs -> 21.2μs (17.7% faster)
    # The order should be: amount, label, note
    expected = f"bitcoin:{addr}?amount=1&label=Alice&note=Payment"

def test_amount_fractional_satoshis():
    # Amount less than 1 BTC, fractional
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    codeflash_output = create_bip21_uri(addr, 12345678, None); uri = codeflash_output # 21.2μs -> 18.1μs (16.9% faster)

def test_amount_trailing_zeros():
    # Amount with trailing zeros, should not have trailing zeros in URI
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    codeflash_output = create_bip21_uri(addr, 1000000, None); uri = codeflash_output # 20.6μs -> 17.3μs (19.3% faster)

def test_message_unicode():
    # Unicode message should be percent-encoded
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    msg = "Спасибо за помощь"  # "Thank you for help" in Russian
    codeflash_output = create_bip21_uri(addr, 100000000, msg); uri = codeflash_output # 25.6μs -> 23.0μs (11.1% faster)
    expected = f"bitcoin:{addr}?amount=1&message={urllib.parse.quote(msg)}"

def test_extra_query_params_unicode():
    # Extra param value with unicode
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    extra = {"label": "Донат"}
    codeflash_output = create_bip21_uri(addr, 100000000, None, extra_query_params=extra); uri = codeflash_output # 25.9μs -> 21.8μs (18.9% faster)
    expected = f"bitcoin:{addr}?amount=1&label={urllib.parse.quote('Донат')}"

def test_extra_query_params_key_is_encoded():
    # Key must be url-quoted (no special chars)
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    extra = {"label": "Alice", "note": "Payment"}
    # keys are valid
    codeflash_output = create_bip21_uri(addr, 100000000, None, extra_query_params=extra); uri = codeflash_output # 24.6μs -> 21.1μs (16.5% faster)
    expected = f"bitcoin:{addr}?amount=1&label=Alice&note=Payment"


def test_large_scale_many_extra_params():
    # URI with many extra params (up to 1000)
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    extra = {f"key{i}": f"value{i}" for i in range(1000)}
    codeflash_output = create_bip21_uri(addr, 100000000, "Bulk", extra_query_params=extra); uri = codeflash_output # 831μs -> 733μs (13.3% faster)
    # Check that all keys/values are present
    for i in range(1000):
        k = f"key{i}"
        v = f"value{i}"

def test_large_scale_long_message():
    # Very long message (1000 chars)
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    msg = "A" * 1000
    codeflash_output = create_bip21_uri(addr, 100000000, msg); uri = codeflash_output # 35.7μs -> 30.9μs (15.6% faster)
    # Message should be percent-encoded and present
    encoded_msg = urllib.parse.quote(msg)

def test_large_scale_long_address():
    # Long valid segwit address (62 chars)
    addr = "bc1p" + "a"*58
    codeflash_output = create_bip21_uri(addr, 100000000, None); uri = codeflash_output # 54.9μs -> 55.7μs (1.47% slower)

def test_large_scale_large_amount():
    # Large amount (max 21 million BTC)
    addr = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
    amount_sat = 21_000_000 * 100_000_000
    codeflash_output = create_bip21_uri(addr, amount_sat, None); uri = codeflash_output # 25.6μs -> 21.4μs (19.2% faster)

def test_large_scale_all_fields():
    # All fields populated, large scale
    addr = "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080"
    amount_sat = 123456789
    msg = "Long message " * 50
    extra = {f"param{i}": f"value{i}" for i in range(100)}
    codeflash_output = create_bip21_uri(addr, amount_sat, msg, extra_query_params=extra); uri = codeflash_output # 36.4μs -> 36.5μs (0.345% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-create_bip21_uri-mhxwk182 and push.