⚡️ Speed up function derive_keys by 18%

[codeflash-ai]

📄 18% (0.18x) speedup for derive_keys in electrum/plugins/digitalbitbox/digitalbitbox.py

⏱️ Runtime : 5.43 milliseconds → 4.62 milliseconds (best of 250 runs)

📝 Explanation and details

The optimization replaces the inefficient double sha256 call with direct hashlib.sha256 usage, eliminating unnecessary function overhead and object conversions.

Key Changes:

• Removed function call overhead: The original code called the sha256() wrapper function twice, each adding function call overhead and an unnecessary bytes() conversion
• Direct hashlib usage: The optimized version uses hashlib.sha256().digest() directly, chaining the two SHA-256 operations without intermediate conversions
• Eliminated redundant conversions: Removed the bytes(sha256(sha256(x))) pattern which was converting already-bytes output back to bytes

Performance Impact:
The line profiler shows the critical improvement - the double SHA-256 computation dropped from 8.16ms (71.7% of function time) to 3.23ms (54.9% of function time), a ~60% reduction in the most expensive operation. This translates to an overall 17% speedup.

Hot Path Analysis:
Based on the function reference, derive_keys is called in hid_send_encrypt, which appears to be part of hardware wallet communication - likely executed frequently during transaction operations. The optimization will benefit any workflow involving multiple cryptographic operations with the Digital Bitbox hardware wallet.

Test Case Performance:
The annotated tests show consistent 10-20% improvements across all input types (strings, bytes, unicode, large inputs), with particularly strong gains (15-22%) for byte inputs and repeated operations, indicating the optimization scales well across different usage patterns.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import hashlib  # used for reference calculation

# imports
import pytest  # used for our unit tests
from electrum.plugins.digitalbitbox.digitalbitbox import derive_keys

# unit tests

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

def test_derive_keys_bytes_basic():
    # Test with simple byte input
    input_bytes = b'hello'
    k1, k2 = derive_keys(input_bytes) # 9.94μs -> 9.00μs (10.5% faster)
    # Deterministic output: same input gives same output
    k1b, k2b = derive_keys(input_bytes) # 2.23μs -> 1.92μs (15.6% faster)

def test_derive_keys_str_basic():
    # Test with simple string input
    input_str = 'world'
    k1, k2 = derive_keys(input_str) # 5.25μs -> 4.65μs (12.9% faster)
    # Deterministic output: same input gives same output
    k1b, k2b = derive_keys(input_str) # 2.25μs -> 1.89μs (18.7% faster)

def test_derive_keys_different_inputs():
    # Different inputs must produce different outputs
    k1a, k2a = derive_keys('abc') # 5.08μs -> 4.44μs (14.4% faster)
    k1b, k2b = derive_keys('def') # 2.21μs -> 1.93μs (14.1% faster)


def test_derive_keys_empty_string():
    # Test with empty string input
    k1, k2 = derive_keys('') # 10.4μs -> 9.31μs (12.0% faster)
    # Should be deterministic
    k1b, k2b = derive_keys('') # 2.30μs -> 1.99μs (15.5% faster)

def test_derive_keys_empty_bytes():
    # Test with empty bytes input
    k1, k2 = derive_keys(b'') # 5.02μs -> 4.11μs (22.0% faster)
    # Should match empty string result
    k1s, k2s = derive_keys('') # 2.40μs -> 2.09μs (14.6% faster)

def test_derive_keys_unicode_input():
    # Test with unicode string input
    input_str = '你好世界'
    k1, k2 = derive_keys(input_str) # 5.23μs -> 4.58μs (14.1% faster)

def test_derive_keys_long_string():
    # Test with a long string input
    input_str = 'a' * 1000
    k1, k2 = derive_keys(input_str) # 5.87μs -> 5.12μs (14.6% faster)

def test_derive_keys_long_bytes():
    # Test with a long bytes input
    input_bytes = b'\x00\xff' * 500
    k1, k2 = derive_keys(input_bytes) # 5.06μs -> 4.63μs (9.37% faster)

def test_derive_keys_non_ascii_bytes():
    # Test with non-ASCII bytes
    input_bytes = bytes([0, 255, 128, 64, 32])
    k1, k2 = derive_keys(input_bytes) # 4.76μs -> 4.13μs (15.1% faster)

def test_derive_keys_type_error():
    # Test that non-str/non-bytes input raises TypeError
    with pytest.raises(TypeError):
        derive_keys(12345) # 1.33μs -> 1.26μs (5.81% faster)
    with pytest.raises(TypeError):
        derive_keys([1, 2, 3]) # 716ns -> 780ns (8.21% slower)

def test_derive_keys_str_vs_bytes():
    # Test that 'abc' and b'abc' produce same result
    k1a, k2a = derive_keys('abc') # 5.99μs -> 5.26μs (13.8% faster)
    k1b, k2b = derive_keys(b'abc') # 2.24μs -> 1.98μs (13.6% faster)

def test_derive_keys_str_encoding():
    # Test that different encodings of same string produce same result
    s = 'café'
    k1a, k2a = derive_keys(s) # 4.99μs -> 4.25μs (17.5% faster)
    k1b, k2b = derive_keys(s.encode('utf8')) # 2.18μs -> 1.93μs (12.8% faster)

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

def test_derive_keys_many_unique_inputs():
    # Test with many unique inputs to check for collisions and performance
    results = set()
    for i in range(1000):
        k1, k2 = derive_keys(f'input_{i}') # 1.74ms -> 1.49ms (17.4% faster)
        results.add((k1, k2))

def test_derive_keys_large_input_bytes():
    # Test with a very large bytes input (1000 bytes)
    input_bytes = b'a' * 1000
    k1, k2 = derive_keys(input_bytes) # 8.32μs -> 7.72μs (7.85% faster)

def test_derive_keys_large_input_str():
    # Test with a very large string input (1000 chars)
    input_str = 'b' * 1000
    k1, k2 = derive_keys(input_str) # 5.79μs -> 5.26μs (10.1% faster)

def test_derive_keys_performance():
    # Performance: derive_keys should not take excessive time for 1000 calls
    import time
    start = time.time()
    for i in range(1000):
        derive_keys(f'perf_test_{i}') # 1.75ms -> 1.47ms (18.7% 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.

import hashlib

# imports
import pytest  # used for our unit tests
from electrum.plugins.digitalbitbox.digitalbitbox import derive_keys

# unit tests

# --- Basic Test Cases ---

def test_derive_keys_basic_ascii():
    # Test with a simple ASCII string
    k1, k2 = derive_keys("hello") # 7.41μs -> 6.80μs (8.94% faster)
    # Check determinism: same input, same output
    k1b, k2b = derive_keys("hello") # 2.14μs -> 1.81μs (18.1% faster)

def test_derive_keys_basic_bytes():
    # Test with bytes input
    input_bytes = b"test input"
    k1, k2 = derive_keys(input_bytes) # 4.46μs -> 3.76μs (18.4% faster)
    # Check determinism: same input, same output
    k1b, k2b = derive_keys(input_bytes) # 2.08μs -> 1.74μs (19.7% faster)

def test_derive_keys_different_inputs():
    # Different inputs yield different outputs
    k1a, k2a = derive_keys("input1") # 4.55μs -> 4.04μs (12.7% faster)
    k1b, k2b = derive_keys("input2") # 2.25μs -> 1.91μs (17.5% faster)

def test_derive_keys_unicode_string():
    # Test with a unicode string
    s = "こんにちは"  # Japanese for "hello"
    k1, k2 = derive_keys(s) # 4.98μs -> 4.33μs (15.0% faster)

# --- Edge Test Cases ---

def test_derive_keys_empty_string():
    # Empty string input
    k1, k2 = derive_keys("") # 4.68μs -> 4.17μs (12.4% faster)
    # Should be deterministic
    k1b, k2b = derive_keys("") # 2.17μs -> 1.87μs (15.8% faster)

def test_derive_keys_empty_bytes():
    # Empty bytes input
    k1, k2 = derive_keys(b"") # 4.32μs -> 3.79μs (13.9% faster)
    # Should match empty string input (since to_bytes treats both as b'')
    k1s, k2s = derive_keys("") # 2.32μs -> 2.05μs (13.2% faster)

def test_derive_keys_max_byte_value():
    # Input with all bytes set to 0xff
    data = bytes([0xff] * 32)
    k1, k2 = derive_keys(data) # 4.40μs -> 3.87μs (13.6% faster)
    # Deterministic
    k1b, k2b = derive_keys(data) # 2.04μs -> 1.80μs (13.6% faster)

def test_derive_keys_ascii_nulls():
    # Input with null bytes
    data = b"\x00" * 16
    k1, k2 = derive_keys(data) # 4.34μs -> 3.82μs (13.7% faster)

def test_derive_keys_non_utf8_bytes():
    # Input with bytes not valid UTF-8
    data = b"\xff\xfe\xfd\xfc"
    k1, k2 = derive_keys(data) # 4.48μs -> 3.88μs (15.6% faster)

def test_derive_keys_type_error():
    # Non-str, non-bytes input should raise TypeError
    with pytest.raises(TypeError):
        derive_keys(12345) # 1.33μs -> 1.31μs (1.68% faster)
    with pytest.raises(TypeError):
        derive_keys(None) # 697ns -> 771ns (9.60% slower)
    with pytest.raises(TypeError):
        derive_keys([1,2,3]) # 568ns -> 569ns (0.176% slower)

def test_derive_keys_unicode_surrogate():
    # Input with a lone surrogate (which is invalid in UTF-8)
    s = "\udc80"
    with pytest.raises(UnicodeEncodeError):
        derive_keys(s) # 3.12μs -> 3.10μs (0.840% faster)

def test_derive_keys_long_string():
    # Long string input, but still under 1000 bytes
    s = "a" * 999
    k1, k2 = derive_keys(s) # 8.42μs -> 7.72μs (9.08% faster)

def test_derive_keys_long_bytes():
    # Long bytes input, 999 bytes
    b = b"x" * 999
    k1, k2 = derive_keys(b) # 5.41μs -> 4.87μs (11.2% faster)

# --- Large Scale Test Cases ---

def test_derive_keys_unique_outputs_large_set():
    # Test that 1000 unique inputs produce 1000 unique outputs
    results = set()
    for i in range(1000):
        k1, k2 = derive_keys(f"input-{i}") # 1.75ms -> 1.49ms (17.7% faster)
        # Use the tuple of both keys for uniqueness
        results.add((k1, k2))

def test_derive_keys_performance_large_inputs():
    # Test that function works efficiently with large inputs (under 1000 bytes)
    large_input = b"a" * 999
    # Should not raise or hang
    k1, k2 = derive_keys(large_input) # 8.85μs -> 8.10μs (9.30% faster)

def test_derive_keys_collision_resistance():
    # Ensure that small changes in input produce different outputs
    base = "collision-test"
    k1, k2 = derive_keys(base) # 5.19μs -> 4.50μs (15.4% faster)
    k1b, k2b = derive_keys(base + "a") # 2.16μs -> 1.88μs (15.0% faster)
    k1c, k2c = derive_keys(base[:-1]) # 1.87μs -> 1.55μs (20.1% faster)

To edit these changes git checkout codeflash/optimize-derive_keys-mhxk9rjc and push.