⚡️ Speed up function derive_keys by 19%

[codeflash-ai]

📄 19% (0.19x) speedup for derive_keys in electrum/plugins/digitalbitbox/digitalbitbox.py

⏱️ Runtime : 8.53 milliseconds → 7.16 milliseconds (best of 181 runs)

📝 Explanation and details

The optimization achieves a 19% speedup by eliminating redundant operations in the sha256d function, which is the performance bottleneck in the cryptographic key derivation process.

Key Optimizations Applied:

1. Conditional type conversion: Added if not isinstance(x, bytes): check to avoid unnecessary to_bytes() calls when the input is already bytes. The line profiler shows this saves ~2.6 million nanoseconds per hit on the conversion line.

2. Eliminated redundant bytes() wrapper: The original code wrapped sha256(sha256(x)) in bytes(), but hashlib.sha256().digest() already returns bytes. This removes an unnecessary object creation.

3. Direct hashlib calls: Replaced the dependency on an external sha256 function with direct hashlib.sha256() calls, reducing function call overhead and improving clarity.

Performance Impact:

• The sha256d function time dropped from 16.68ms to 10.82ms (~35% faster)
• Overall derive_keys performance improved from 8.53ms to 7.16ms (19% speedup)
• Most significant gains occur with bytes inputs (20-27% faster) since they skip the conversion entirely
• String inputs still benefit (8-18% faster) from the eliminated redundant operations

Test Case Performance:
The optimization is particularly effective for:

• Bytes inputs: 20-27% faster across all test cases
• Repeated operations: Performance scales well in batch processing scenarios (17-24% improvement in large-scale tests)
• Mixed workloads: Benefits both string and bytes inputs consistently

This optimization is especially valuable in cryptocurrency applications where sha256d (double SHA-256) is frequently called for address derivation, transaction hashing, and other cryptographic operations.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

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_basic_bytes_input():
    # Test with simple bytes input
    data = b"test"
    k1, k2 = derive_keys(data) # 6.58μs -> 5.31μs (23.8% faster)
    # Should be deterministic
    k1b, k2b = derive_keys(data) # 2.60μs -> 2.04μs (27.3% faster)

def test_basic_str_input():
    # Test with simple string input
    data = "hello world"
    k1, k2 = derive_keys(data) # 5.54μs -> 4.94μs (12.1% faster)
    # Should be deterministic
    k1b, k2b = derive_keys(data) # 2.78μs -> 2.29μs (21.4% faster)

def test_basic_unicode_input():
    # Test with unicode string input
    data = "こんにちは世界"  # Japanese for "Hello, World"
    k1, k2 = derive_keys(data) # 5.64μs -> 5.10μs (10.6% faster)

def test_basic_empty_bytes():
    # Test with empty bytes
    data = b""
    k1, k2 = derive_keys(data) # 5.23μs -> 4.29μs (21.8% faster)

def test_basic_empty_str():
    # Test with empty string
    data = ""
    k1, k2 = derive_keys(data) # 5.43μs -> 5.05μs (7.42% faster)

# --- Edge Test Cases ---

def test_edge_long_bytes():
    # Test with long bytes input (1000 bytes)
    data = b"a" * 1000
    k1, k2 = derive_keys(data) # 6.24μs -> 5.12μs (21.8% faster)

def test_edge_long_str():
    # Test with long string input (1000 chars)
    data = "b" * 1000
    k1, k2 = derive_keys(data) # 6.77μs -> 6.22μs (8.76% faster)

def test_edge_non_ascii_bytes():
    # Test with bytes containing non-ASCII values
    data = bytes([0, 255, 128, 64, 32, 16])
    k1, k2 = derive_keys(data) # 5.31μs -> 4.33μs (22.7% faster)

def test_edge_non_ascii_str():
    # Test with string containing non-ASCII characters
    data = "𝔘𝔫𝔦𝔠𝔬𝔡𝔢"  # Gothic Unicode letters
    k1, k2 = derive_keys(data) # 6.00μs -> 5.40μs (11.2% faster)

def test_edge_null_bytes():
    # Test with bytes containing null bytes
    data = b"\x00\x00\x00\x00"
    k1, k2 = derive_keys(data) # 5.17μs -> 4.45μs (16.2% faster)

def test_edge_null_str():
    # Test with string containing null character
    data = "\x00\x00\x00"
    k1, k2 = derive_keys(data) # 5.65μs -> 5.08μs (11.3% faster)

def test_edge_type_error():
    # Test with unsupported input type (int)
    with pytest.raises(TypeError):
        derive_keys(123) # 1.64μs -> 1.66μs (1.21% slower)

def test_edge_type_error_float():
    # Test with unsupported input type (float)
    with pytest.raises(TypeError):
        derive_keys(1.23) # 1.48μs -> 1.49μs (0.539% slower)

def test_edge_type_error_list():
    # Test with unsupported input type (list)
    with pytest.raises(TypeError):
        derive_keys([1,2,3]) # 1.41μs -> 1.48μs (4.47% slower)

def test_edge_type_error_dict():
    # Test with unsupported input type (dict)
    with pytest.raises(TypeError):
        derive_keys({'a': 1}) # 1.40μs -> 1.47μs (5.03% slower)

def test_edge_different_inputs_produce_different_keys():
    # Different inputs should produce different outputs
    k1a, k2a = derive_keys("input_a") # 9.14μs -> 8.44μs (8.33% faster)
    k1b, k2b = derive_keys("input_b") # 2.97μs -> 2.66μs (11.7% faster)

def test_edge_same_sha256d_produces_same_keys():
    # If two inputs have the same sha256d, keys should be the same
    # Find two different inputs with same sha256d (extremely rare, so we use identical input)
    data = "same"
    k1, k2 = derive_keys(data) # 6.06μs -> 5.31μs (14.0% faster)
    k1b, k2b = derive_keys(data) # 2.88μs -> 2.43μs (18.2% faster)

# --- Large Scale Test Cases ---

def test_large_scale_many_unique_inputs():
    # Test with many unique inputs to ensure deterministic and unique outputs
    keys_set = set()
    for i in range(100):
        data = f"input_{i}"
        k1, k2 = derive_keys(data) # 226μs -> 192μs (17.4% faster)
        # Store as tuple for uniqueness check
        keys_set.add((k1, k2))

def test_large_scale_large_bytes():
    # Test with the largest allowed bytes input (1000 bytes)
    data = b"x" * 1000
    k1, k2 = derive_keys(data) # 6.80μs -> 5.36μs (26.8% faster)

def test_large_scale_performance():
    # Test performance by running derive_keys 1000 times
    # Should complete within reasonable time and memory (pytest will enforce timeout if needed)
    for i in range(1000):
        data = f"perf_{i}"
        k1, k2 = derive_keys(data) # 2.19ms -> 1.87ms (17.2% faster)

def test_large_scale_bytes_variation():
    # Test with 1000 different bytes inputs
    for i in range(1000):
        data = bytes([i % 256]) * 10  # 10 bytes, repeated value
        k1, k2 = derive_keys(data) # 2.11ms -> 1.69ms (24.5% faster)

def test_large_scale_unicode_variation():
    # Test with 1000 different unicode strings
    for i in range(1000):
        data = chr(0x1000 + i) * 5  # 5 repeated unicode chars
        k1, k2 = derive_keys(data) # 2.23ms -> 1.91ms (16.8% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import hashlib  # used for reference hash calculations

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

# ---------------------------
# Unit Tests for derive_keys
# ---------------------------

# ---------------------------
# 1. Basic Test Cases
# ---------------------------

def test_basic_ascii_string():
    # Test with a simple ASCII string
    k1, k2 = derive_keys("hello") # 10.4μs -> 9.45μs (10.5% faster)
    # Deterministic: same input, same output
    k1b, k2b = derive_keys("hello") # 2.84μs -> 2.42μs (17.4% faster)
    # Different input, different output
    k1c, k2c = derive_keys("world") # 2.31μs -> 1.96μs (18.0% faster)

def test_basic_bytes_input():
    # Test with bytes input
    s = b"test input"
    k1, k2 = derive_keys(s) # 5.38μs -> 4.47μs (20.3% faster)
    k1b, k2b = derive_keys("test input") # 3.04μs -> 2.73μs (11.2% faster)

def test_basic_unicode_string():
    # Test with unicode characters
    s = "こんにちは"  # Japanese for "Hello"
    k1, k2 = derive_keys(s) # 5.76μs -> 5.20μs (10.8% faster)
    # Deterministic
    k1b, k2b = derive_keys(s) # 2.74μs -> 2.40μs (14.5% faster)

def test_basic_empty_string():
    # Test with empty string
    k1, k2 = derive_keys("") # 5.27μs -> 4.73μs (11.4% faster)
    # Deterministic
    k1b, k2b = derive_keys("") # 2.68μs -> 2.33μs (15.1% faster)

def test_basic_empty_bytes():
    # Test with empty bytes
    k1, k2 = derive_keys(b"") # 5.17μs -> 4.32μs (19.7% faster)
    k1b, k2b = derive_keys("") # 2.96μs -> 2.69μs (9.96% faster)

# ---------------------------
# 2. Edge Test Cases
# ---------------------------

def test_edge_long_string():
    # Test with a long string (but <1000 chars)
    s = "a" * 999
    k1, k2 = derive_keys(s) # 6.59μs -> 5.67μs (16.2% faster)

def test_edge_long_bytes():
    # Test with long bytes input
    s = b"\xff" * 999
    k1, k2 = derive_keys(s) # 5.90μs -> 5.05μs (16.8% faster)

def test_edge_non_ascii_bytes():
    # Test with non-ASCII bytes
    s = bytes([0, 127, 128, 255])
    k1, k2 = derive_keys(s) # 5.37μs -> 4.45μs (20.5% faster)

def test_edge_unicode_surrogate():
    # Test with a string containing surrogate pairs
    s = "\U0001F600"  # 😀 emoji
    k1, k2 = derive_keys(s) # 5.71μs -> 5.27μs (8.34% faster)

def test_edge_type_error():
    # Test with invalid input type (e.g., int, list)
    with pytest.raises(TypeError):
        derive_keys(12345) # 1.63μs -> 1.63μs (0.429% slower)
    with pytest.raises(TypeError):
        derive_keys([1, 2, 3]) # 964ns -> 942ns (2.34% faster)
    with pytest.raises(TypeError):
        derive_keys(None) # 673ns -> 750ns (10.3% slower)

def test_edge_mutation_resistance():
    # Changing a single byte should change the output (avalanche effect)
    s1 = b"test input"
    s2 = b"test inpuu"
    k1, k2 = derive_keys(s1) # 7.20μs -> 6.39μs (12.6% faster)
    k1b, k2b = derive_keys(s2) # 2.73μs -> 2.24μs (22.0% faster)

def test_edge_case_sensitivity():
    # "abc" vs "ABC" should yield different outputs
    k1, k2 = derive_keys("abc") # 6.10μs -> 5.35μs (14.0% faster)
    k1b, k2b = derive_keys("ABC") # 2.80μs -> 2.50μs (12.2% faster)

def test_edge_output_non_overlap():
    # The two keys returned should not be equal
    s = "some input"
    k1, k2 = derive_keys(s) # 5.69μs -> 4.92μs (15.5% faster)


def test_large_scale_unique_outputs():
    # For a large number of unique inputs, outputs should be unique
    n = 500
    outputs = set()
    for i in range(n):
        s = f"input-{i}"
        k1, k2 = derive_keys(s) # 1.11ms -> 944μs (18.0% faster)
        outputs.add((k1, k2))

def test_large_scale_performance():
    # Test that the function can handle a large input efficiently
    s = "x" * 1000  # 1000 chars
    k1, k2 = derive_keys(s) # 9.70μs -> 8.67μs (11.9% faster)


def test_large_scale_bytes_vs_str():
    # For a batch of inputs, bytes and str versions should match
    for i in range(100):
        s = f"input-{i}"
        k1, k2 = derive_keys(s) # 234μs -> 200μs (17.0% faster)
        k1b, k2b = derive_keys(s.encode("utf8"))
# 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-derive_keys-mhp18p23 and push.