⚡️ Speed up function encode_hex by 32%

[codeflash-ai]

📄 32% (0.32x) speedup for encode_hex in python/ccxt/static_dependencies/ethereum/utils/hexadecimal.py

⏱️ Runtime : 134 microseconds → 102 microseconds (best of 250 runs)

📝 Explanation and details

The optimized code achieves a 31% speedup through several key performance improvements:

Primary Optimizations

1. Eliminated Redundant Type Checking

• The original code called is_string(value) which checks isinstance(value, string_types), then immediately performed another isinstance(value, (bytes, bytearray)) check
• The optimized version directly checks for specific types (bytes/bytearray first, then str) avoiding the double type checking overhead
• Line profiler shows the original is_string() call took 39.7% of total time (271,840ns), which is completely eliminated

2. Inlined Function Call Logic

• The original code called add_0x_prefix() for every result, adding function call overhead
• The optimized version inlines the prefix checking logic (hexed.startswith(("0x", "0X"))) directly in encode_hex
• This eliminates the function call overhead that consumed 43.8% of the original runtime (300,235ns)

3. Streamlined Control Flow

• Reorganized the type checking to handle the most common cases first (bytes/bytearray then str)
• Combined the hexlify and decode operations in the same conditional branches
• Reduced the total number of branches and improved cache locality

Performance Impact by Test Case

The optimizations show consistent improvements across all test scenarios:

• Bytes/bytearray inputs: 42-57% faster (best case) due to eliminated is_string() call and direct type checking
• String inputs: 32-40% faster from avoiding double type checking and inlined prefix logic
• Large inputs: 18-35% faster, showing the optimizations scale well
• Error cases: Mixed results (some 8% faster, others slightly slower) as error handling paths are less optimized

Key Technical Benefits

• Reduced function call overhead: Eliminates is_string() and add_0x_prefix() calls from the hot path
• Better branch prediction: Direct isinstance checks are more predictable than nested function calls
• Fewer string operations: Combines hexlify/decode operations and prefix checking in single code paths

The optimization is particularly effective for this function because it's likely called frequently in cryptocurrency/blockchain applications where hex encoding is a common operation, making these micro-optimizations meaningful at scale.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import binascii
from typing import Any

imports

import pytest # used for our unit tests
from ccxt.static_dependencies.ethereum.utils.hexadecimal import encode_hex

Minimal stubs for missing types and functions

class HexStr(str):
pass
from ccxt.static_dependencies.ethereum.utils.hexadecimal import encode_hex

unit tests

-----------------------

Basic Test Cases

-----------------------

def test_encode_hex_ascii_string():
# Basic ASCII string
codeflash_output = encode_hex("hello") # 2.25μs -> 1.70μs (32.6% faster)
codeflash_output = encode_hex("Ethereum") # 1.20μs -> 904ns (32.5% faster)

def test_encode_hex_empty_string():
# Empty string input
codeflash_output = encode_hex("") # 2.03μs -> 1.53μs (32.5% faster)

def test_encode_hex_bytes_input():
# Bytes input
codeflash_output = encode_hex(b"hello") # 2.03μs -> 1.42μs (42.9% faster)
codeflash_output = encode_hex(b"Ethereum") # 1.01μs -> 705ns (44.0% faster)

def test_encode_hex_bytearray_input():
# Bytearray input
codeflash_output = encode_hex(bytearray(b"hello")) # 2.28μs -> 1.49μs (52.7% faster)
codeflash_output = encode_hex(bytearray(b"Ethereum")) # 1.14μs -> 727ns (56.3% faster)

def test_encode_hex_numeric_string():
# Numeric string
codeflash_output = encode_hex("12345") # 2.16μs -> 1.55μs (39.0% faster)

def test_encode_hex_special_ascii_chars():
# Special ASCII characters
codeflash_output = encode_hex("!@#$%^&*()_+") # 2.19μs -> 1.54μs (42.4% faster)

-----------------------

Edge Test Cases

-----------------------

def test_encode_hex_non_string_input():
# Non-string, non-bytes input should raise TypeError
with pytest.raises(TypeError):
encode_hex(12345) # 975ns -> 898ns (8.57% faster)
with pytest.raises(TypeError):
encode_hex(None) # 518ns -> 599ns (13.5% slower)
with pytest.raises(TypeError):
encode_hex([1,2,3]) # 394ns -> 424ns (7.08% slower)
with pytest.raises(TypeError):
encode_hex({'a': 1}) # 433ns -> 377ns (14.9% faster)

def test_encode_hex_unicode_string():
# Unicode string with non-ASCII character should raise UnicodeEncodeError
with pytest.raises(UnicodeEncodeError):
encode_hex("héllo") # 2.66μs -> 2.52μs (5.47% faster)

def test_encode_hex_bytes_non_ascii():
# bytes containing non-ASCII values are allowed
codeflash_output = encode_hex(b"\xff\xfe") # 2.31μs -> 1.66μs (39.5% faster)

def test_encode_hex_bytearray_non_ascii():
# bytearray containing non-ASCII values are allowed
codeflash_output = encode_hex(bytearray([255, 254])) # 2.51μs -> 1.62μs (54.5% faster)

def test_encode_hex_already_hex_string():
# Input string that looks like hex should still be encoded as ASCII
codeflash_output = encode_hex("0x68656c6c6f") # 2.36μs -> 1.74μs (35.4% faster)

def test_encode_hex_uppercase_ascii():
# Uppercase ASCII string
codeflash_output = encode_hex("HELLO") # 2.29μs -> 1.65μs (38.9% faster)

def test_encode_hex_space_and_newline():
# Space and newline characters
codeflash_output = encode_hex("hello world\n") # 2.21μs -> 1.57μs (40.6% faster)

def test_encode_hex_control_chars():
# Control characters (ASCII 0-31)
control_chars = "".join(chr(i) for i in range(32))
expected_hex = "0x" + "".join(f"{i:02x}" for i in range(32))
codeflash_output = encode_hex(control_chars) # 2.28μs -> 1.73μs (31.8% faster)

def test_encode_hex_bytes_with_zeroes():
# Bytes with zeroes
codeflash_output = encode_hex(b"\x00\x01\x02") # 2.00μs -> 1.45μs (38.2% faster)

def test_encode_hex_bytearray_with_zeroes():
# Bytearray with zeroes
codeflash_output = encode_hex(bytearray([0, 1, 2])) # 2.35μs -> 1.51μs (55.4% faster)

def test_encode_hex_bytes_empty():
# Empty bytes
codeflash_output = encode_hex(b"") # 1.91μs -> 1.32μs (44.3% faster)

def test_encode_hex_bytearray_empty():
# Empty bytearray
codeflash_output = encode_hex(bytearray()) # 2.24μs -> 1.47μs (52.5% faster)

-----------------------

Large Scale Test Cases

-----------------------

def test_encode_hex_large_ascii_string():
# Large string (1000 'a's)
s = "a" * 1000
expected = "0x" + "61" * 1000
codeflash_output = encode_hex(s) # 4.03μs -> 3.42μs (17.8% faster)

def test_encode_hex_large_bytes():
# Large bytes (1000 bytes, value 0x7f)
b = bytes([0x7f] * 1000)
expected = "0x" + "7f" * 1000
codeflash_output = encode_hex(b) # 3.24μs -> 2.54μs (27.8% faster)

def test_encode_hex_large_bytearray():
# Large bytearray (1000 bytes, value 0x80)
b = bytearray([0x80] * 1000)
expected = "0x" + "80" * 1000
codeflash_output = encode_hex(b) # 3.49μs -> 2.67μs (30.6% faster)

def test_encode_hex_large_mixed_ascii():
# Large string with mixed ASCII chars
s = "".join(chr(32 + (i % 95)) for i in range(1000)) # cycle through printable ASCII
expected = "0x" + "".join(f"{ord(c):02x}" for c in s)
codeflash_output = encode_hex(s) # 3.75μs -> 2.96μs (26.9% faster)

def test_encode_hex_large_control_bytes():
# Large bytes with control chars (0-31 repeated)
b = bytes([i % 32 for i in range(1000)])
expected = "0x" + "".join(f"{i % 32:02x}" for i in range(1000))
codeflash_output = encode_hex(b) # 3.23μs -> 2.63μs (22.9% faster)

-----------------------

Determinism Test

-----------------------

def test_encode_hex_determinism():
# Multiple calls with same input yield same output
s = "teststring"
codeflash_output = encode_hex(s); out1 = codeflash_output # 2.48μs -> 1.80μs (37.5% faster)
codeflash_output = encode_hex(s); out2 = codeflash_output # 1.01μs -> 729ns (38.5% faster)

codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

#------------------------------------------------
import binascii

--- Begin: ccxt/static_dependencies/ethereum/utils/hexadecimal.py ---

function to test

from typing import Any, AnyStr

imports

import pytest # used for our unit tests
from ccxt.static_dependencies.ethereum.utils.hexadecimal import encode_hex

--- End: ccxt/static_dependencies/ethereum/utils/types.py ---

--- Begin: ccxt/static_dependencies/ethereum/typing.py ---

class HexStr(str):
pass
from ccxt.static_dependencies.ethereum.utils.hexadecimal import
encode_hex # --- End: ccxt/static_dependencies/ethereum/utils/hexadecimal.py ---

--- Begin: Unit Tests for encode_hex ---

1. Basic Test Cases

@pytest.mark.parametrize(
"input_val,expected",
[
# Basic ASCII string
("abc", "0x616263"),
# Single character
("A", "0x41"),
# Empty string
("", "0x"),
# ASCII digits
("123", "0x313233"),
# ASCII special characters
("!@#", "0x214023"),
# Already hex-looking string (should encode, not pass through)
("0x616263", "0x3078363136323633"),
]
)
def test_encode_hex_basic_ascii(input_val, expected):
"""Test encoding of basic ASCII strings."""
codeflash_output = encode_hex(input_val) # 15.0μs -> 10.9μs (37.4% faster)

@pytest.mark.parametrize(
"input_val,expected",
[
# bytes input
(b"abc", "0x616263"),
# bytearray input
(bytearray(b"abc"), "0x616263"),
# bytes with special chars
(b"\x00\xff", "0x00ff"),
# bytearray with digits
(bytearray(b"123"), "0x313233"),
]
)
def test_encode_hex_bytes_bytearray(input_val, expected):
"""Test encoding of bytes and bytearray."""
codeflash_output = encode_hex(input_val) # 9.49μs -> 6.58μs (44.3% faster)

2. Edge Test Cases

@pytest.mark.parametrize(
"input_val,expected",
[
# Empty bytes
(b"", "0x"),
# Empty bytearray
(bytearray(b""), "0x"),
# Large single byte value
(b"\xff", "0xff"),
# Non-printable ASCII character
("\x07", "0x07"),
]
)
def test_encode_hex_edge_empty_and_nonprintable(input_val, expected):
"""Test edge cases with empty and non-printable ASCII."""
codeflash_output = encode_hex(input_val) # 8.98μs -> 6.63μs (35.4% faster)

def test_encode_hex_ascii_boundary():
"""Test boundary ASCII values."""
# chr(0) == '\x00'
codeflash_output = encode_hex("\x00") # 2.24μs -> 1.70μs (32.1% faster)
# chr(127) == '\x7f'
codeflash_output = encode_hex("\x7f") # 1.07μs -> 826ns (29.2% faster)

def test_encode_hex_bytearray_mutation():
"""Ensure encode_hex does not mutate input bytearray."""
arr = bytearray(b"abc")
arr_copy = arr[:]
encode_hex(arr) # 2.30μs -> 1.54μs (49.1% faster)

@pytest.mark.parametrize(
"input_val",
[
123, # integer
12.3, # float
None, # NoneType
object(), # generic object
[1,2,3], # list
{"a": 1}, # dict
(b"abc",), # tuple
set([b"abc"]), # set
]
)
def test_encode_hex_typeerror(input_val):
"""Test that non-string/bytes/bytearray types raise TypeError."""
with pytest.raises(TypeError):
encode_hex(input_val) # 8.24μs -> 7.56μs (9.05% faster)

def test_encode_hex_unicode_error():
"""Test that non-ASCII strings raise UnicodeEncodeError."""
# e.g., 'é' is not ASCII
with pytest.raises(UnicodeEncodeError):
encode_hex("café") # 2.88μs -> 2.59μs (11.1% faster)

def test_encode_hex_no_double_0x():
"""Test that output is always prefixed with a single 0x, never double."""
# Input is bytes, output should be 0x-prefixed
codeflash_output = encode_hex(b"abc"); out = codeflash_output # 3.08μs -> 2.00μs (54.3% faster)
# Input already looks like a hex string, but is encoded, not passed through
codeflash_output = encode_hex("0x616263"); out2 = codeflash_output # 1.54μs -> 1.20μs (29.2% faster)

3. Large Scale Test Cases

def test_encode_hex_large_string():
"""Test encoding of a long ASCII string (1000 chars)."""
s = "a" * 1000
expected = "0x" + "61" * 1000
codeflash_output = encode_hex(s) # 3.90μs -> 3.29μs (18.6% faster)

def test_encode_hex_large_bytes():
"""Test encoding of a long bytes object (1000 bytes)."""
b = b"\xff" * 1000
expected = "0x" + "ff" * 1000
codeflash_output = encode_hex(b) # 3.18μs -> 2.58μs (23.5% faster)

def test_encode_hex_large_bytearray():
"""Test encoding of a long bytearray (1000 bytes)."""
ba = bytearray([i % 256 for i in range(1000)])
expected = "0x" + "".join(f"{i%256:02x}" for i in range(1000))
codeflash_output = encode_hex(ba) # 3.76μs -> 2.80μs (34.5% faster)

def test_encode_hex_performance_short():
"""Test that encoding a 1000-char string is reasonably fast."""
import time
s = "b" * 1000
start = time.perf_counter()
codeflash_output = encode_hex(s); result = codeflash_output # 3.74μs -> 3.08μs (21.2% faster)
duration = time.perf_counter() - start

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-encode_hex-mhw6kfme and push.