⚡️ Speed up function xfp2str by 14%

[codeflash-ai]

📄 14% (0.14x) speedup for xfp2str in electrum/plugins/coldcard/coldcard.py

⏱️ Runtime : 1.35 milliseconds → 1.18 milliseconds (best of 74 runs)

📝 Explanation and details

The optimization removes a redundant .lower() method call from the string formatting chain. In Python's bytes.hex() method, the hexadecimal output is already lowercase by default, making the explicit .lower() call unnecessary.

Key Change:

• Removed .lower() from struct.pack('<I', xfp).hex().lower() → struct.pack('<I', xfp).hex()

Why This Improves Performance:
The .lower() method creates a new string object and iterates through each character to convert uppercase letters to lowercase. Since hex() already returns lowercase hexadecimal digits, this operation is redundant and wastes CPU cycles. Eliminating this unnecessary string method call reduces the per-call overhead by ~67 nanoseconds (531ns → 464ns per hit).

Performance Impact:
The optimization shows consistent 10-35% speedups across all test cases, with particularly strong improvements for:

• Edge cases with leading zeros (20-35% faster)
• Large-scale operations processing many fingerprints (13-16% faster)
• Basic operations on typical values (13-25% faster)

Practical Benefits:
This function appears to be used for displaying cryptocurrency wallet fingerprints in the Coldcard plugin. Since fingerprint conversion may occur frequently during wallet operations, key management, or transaction signing workflows, this micro-optimization can provide measurable improvements in user-facing operations without any behavioral changes.

The optimization is safe because bytes.hex() in Python guarantees lowercase output, maintaining identical functionality while reducing computational overhead.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import struct  # used for byte packing in xfp2str

# imports
import pytest  # used for our unit tests
from electrum.plugins.coldcard.coldcard import xfp2str

# unit tests

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

def test_basic_zero():
    # Test the smallest value, 0
    # struct.pack('<I', 0) == b'\x00\x00\x00\x00'
    codeflash_output = xfp2str(0) # 1.00μs -> 797ns (25.8% faster)

def test_basic_one():
    # Test value 1
    # struct.pack('<I', 1) == b'\x01\x00\x00\x00'
    codeflash_output = xfp2str(1) # 979ns -> 817ns (19.8% faster)

def test_basic_typical():
    # Test a typical fingerprint value
    # struct.pack('<I', 0x12345678) == b'xV4\x12'
    codeflash_output = xfp2str(0x12345678) # 951ns -> 838ns (13.5% faster)

def test_basic_max_uint32():
    # Test the largest possible 32-bit unsigned int
    # struct.pack('<I', 0xFFFFFFFF) == b'\xff\xff\xff\xff'
    codeflash_output = xfp2str(0xFFFFFFFF) # 983ns -> 829ns (18.6% faster)

def test_basic_middle_value():
    # Test a middle value
    # struct.pack('<I', 0x7F7F7F7F) == b'\x7f\x7f\x7f\x7f'
    codeflash_output = xfp2str(0x7F7F7F7F) # 995ns -> 812ns (22.5% faster)

def test_basic_random_value():
    # Test a random value
    # struct.pack('<I', 0xDEADBEEF) == b'\xef\xbe\xad\xde'
    codeflash_output = xfp2str(0xDEADBEEF) # 957ns -> 867ns (10.4% faster)

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



def test_edge_non_integer_input():
    # Should raise a struct.error if input is not an integer
    with pytest.raises(struct.error):
        xfp2str("not an int") # 2.02μs -> 1.98μs (1.82% faster)
    with pytest.raises(struct.error):
        xfp2str(3.1415) # 610ns -> 556ns (9.71% faster)
    with pytest.raises(struct.error):
        xfp2str(None) # 463ns -> 466ns (0.644% slower)

def test_edge_minimum_unsigned():
    # Minimum unsigned value is 0
    codeflash_output = xfp2str(0) # 1.55μs -> 1.20μs (28.8% faster)

def test_edge_maximum_unsigned():
    # Maximum unsigned value is 0xFFFFFFFF
    codeflash_output = xfp2str(0xFFFFFFFF) # 1.22μs -> 1.00μs (21.4% faster)

def test_edge_byte_order():
    # Test that the output is little-endian
    # For 0xAABBCCDD, struct.pack('<I', 0xAABBCCDD) == b'\xdd\xcc\xbb\xaa'
    codeflash_output = xfp2str(0xAABBCCDD) # 1.09μs -> 941ns (16.3% faster)

def test_edge_uppercase_output():
    # Output should always be lowercase
    codeflash_output = xfp2str(0xABCDEF01); result = codeflash_output # 1.09μs -> 808ns (34.4% faster)

def test_edge_leading_zeros():
    # Output should have 8 hex digits, with leading zeros if needed
    codeflash_output = xfp2str(0x00000001) # 1.07μs -> 847ns (26.3% faster)
    codeflash_output = xfp2str(0x0000000A) # 393ns -> 343ns (14.6% faster)
    codeflash_output = xfp2str(0x000000FF) # 316ns -> 289ns (9.34% faster)


def test_large_scale_sequential():
    # Test a range of values from 0 to 999
    for i in range(1000):
        expected = struct.pack('<I', i).hex().lower()
        codeflash_output = xfp2str(i) # 297μs -> 259μs (14.6% faster)

def test_large_scale_random():
    # Test 1000 random 32-bit unsigned integers
    import random
    random.seed(42)  # deterministic
    for _ in range(1000):
        val = random.randint(0, 0xFFFFFFFF)
        expected = struct.pack('<I', val).hex().lower()
        codeflash_output = xfp2str(val) # 304μs -> 270μs (12.6% faster)

def test_large_scale_wraparound():
    # Test values near wraparound points
    for base in [0xFFFFFFF0, 0xFFFFFFFF, 0x100000000, 0x100000010]:
        for offset in range(10):
            val = base + offset
            expected = struct.pack('<I', val).hex().lower()
            codeflash_output = xfp2str(val)


def test_large_scale_all_bytes():
    # Test all combinations of single-byte values in each position
    # Only test for values where one byte is set, rest are zero
    for pos in range(4):
        for byte in range(256):
            val = byte << (8 * pos)
            expected = struct.pack('<I', val).hex().lower()
            codeflash_output = xfp2str(val)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import struct  # used for packing/unpacking integers

# imports
import pytest  # used for our unit tests
from electrum.plugins.coldcard.coldcard import xfp2str

# unit tests

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

def test_basic_zero():
    # Test for zero input
    codeflash_output = xfp2str(0) # 1.84μs -> 1.44μs (27.6% faster)

def test_basic_one():
    # Test for one input
    codeflash_output = xfp2str(1) # 1.19μs -> 964ns (23.1% faster)

def test_basic_typical():
    # Typical fingerprint value
    codeflash_output = xfp2str(0x12345678) # 1.02μs -> 889ns (15.1% faster)

def test_basic_max_uint32():
    # Maximum uint32 value
    codeflash_output = xfp2str(0xFFFFFFFF) # 1.15μs -> 935ns (22.7% faster)

def test_basic_middle_value():
    # Middle value
    codeflash_output = xfp2str(0x80000000) # 1.05μs -> 888ns (18.2% faster)

def test_basic_random_values():
    # Random values
    codeflash_output = xfp2str(0xAABBCCDD) # 985ns -> 745ns (32.2% faster)
    codeflash_output = xfp2str(0xDEADBEEF) # 398ns -> 326ns (22.1% faster)
    codeflash_output = xfp2str(0x01020304) # 351ns -> 295ns (19.0% faster)

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

def test_edge_negative():
    # Negative values: struct.pack with '<I' will raise an error
    with pytest.raises(struct.error):
        xfp2str(-1) # 1.63μs -> 1.62μs (0.679% faster)

def test_edge_overflow():
    # Value exceeding uint32: should raise error
    with pytest.raises(struct.error):
        xfp2str(0x100000000) # 2.48μs -> 2.27μs (9.53% faster)





def test_edge_type_bool():
    # Boolean type: True is 1, False is 0
    codeflash_output = xfp2str(True) # 2.16μs -> 1.74μs (24.1% faster)
    codeflash_output = xfp2str(False) # 465ns -> 379ns (22.7% faster)

def test_edge_leading_zeros():
    # Values with leading zeros
    codeflash_output = xfp2str(0x00000001) # 1.09μs -> 899ns (20.8% faster)
    codeflash_output = xfp2str(0x00000010) # 408ns -> 317ns (28.7% faster)
    codeflash_output = xfp2str(0x00000100) # 324ns -> 276ns (17.4% faster)

def test_edge_endianess():
    # Check that the function is little-endian
    # The hex output should be the little-endian representation
    value = 0x12345678
    packed = struct.pack('<I', value)
    codeflash_output = xfp2str(value) # 796ns -> 664ns (19.9% faster)
    # Compare to big-endian to ensure difference
    packed_be = struct.pack('>I', value)
    codeflash_output = xfp2str(value) # 419ns -> 338ns (24.0% faster)

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

def test_large_range_step():
    # Test a range of values from 0 to 255
    for i in range(0, 256):
        expected = struct.pack('<I', i).hex().lower()
        codeflash_output = xfp2str(i) # 76.3μs -> 66.4μs (14.9% faster)

def test_large_random_sample():
    # Test 100 random values in uint32 range
    import random
    random.seed(42)  # deterministic
    for _ in range(100):
        val = random.randint(0, 0xFFFFFFFF)
        expected = struct.pack('<I', val).hex().lower()
        codeflash_output = xfp2str(val) # 31.2μs -> 27.6μs (13.3% faster)

def test_large_boundary_values():
    # Test boundary values near the edges of uint32
    for val in [0, 1, 0xFFFFFFFE, 0xFFFFFFFF, 0x7FFFFFFF, 0x80000000]:
        expected = struct.pack('<I', val).hex().lower()
        codeflash_output = xfp2str(val) # 2.23μs -> 1.91μs (16.8% faster)

def test_large_all_bytes():
    # Test all combinations where only one byte is set
    for byte_pos in range(4):
        val = 1 << (8 * byte_pos)
        expected = struct.pack('<I', val).hex().lower()
        codeflash_output = xfp2str(val) # 1.55μs -> 1.32μs (17.1% faster)

def test_large_incremental():
    # Test incremental values with step 0x10000000
    for val in range(0, 0xFFFFFFFF + 1, 0x10000000):
        expected = struct.pack('<I', val).hex().lower()
        codeflash_output = xfp2str(val) # 5.23μs -> 4.55μs (15.0% faster)

def test_large_performance():
    # Performance: test 1000 sequential values
    # This is not a strict performance test, but ensures function works for many inputs
    for i in range(0, 1000):
        expected = struct.pack('<I', i).hex().lower()
        codeflash_output = xfp2str(i) # 291μs -> 251μs (15.7% 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.plugins.coldcard.coldcard import xfp2str

def test_xfp2str():
    xfp2str(0)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_0kz7t2kd/tmpmej_dype/test_concolic_coverage.py::test_xfp2str	1.61μs	1.22μs	32.6%✅

To edit these changes git checkout codeflash/optimize-xfp2str-mhotnc02 and push.