cchecksum 0.0.1__py2.py3-none-any.whl

cchecksum/__init__.py

@@ -0,0 +1,2 @@
+from cchecksum.checksum import to_checksum_address
+__all__ = ["to_checksum_address"]

cchecksum/_cchecksum.pyi

@@ -0,0 +1,3 @@
+from eth_typing import ChecksumAddress
+def cchecksum(norm_address_no_0x: str, address_hash_hex_no_0x: str) -> ChecksumAddress:
+    ...

cchecksum/_checksum.pyx

@@ -0,0 +1,54 @@
+def cchecksum(str norm_address_no_0x, str address_hash_hex_no_0x) -> str:
+    """
+    Computes the checksummed version of an Ethereum address.
+
+    This function takes a normalized Ethereum address (without the '0x' prefix) and its corresponding
+    hash (also without the '0x' prefix) and returns the checksummed address as per the Ethereum
+    Improvement Proposal 55 (EIP-55).
+
+    Args:
+        norm_address_no_0x (str): The normalized Ethereum address without the '0x' prefix.
+        address_hash_hex_no_0x (str): The hash of the address, also without the '0x' prefix.
+
+    Returns:
+        The checksummed Ethereum address with the '0x' prefix.
+
+    Examples:
+        >>> cchecksum("b47e3cd837ddf8e4c57f05d70ab865de6e193bbb", "abcdef1234567890abcdef1234567890abcdef12")
+        '0xB47E3Cd837DdF8E4C57F05D70Ab865De6E193BbB'
+
+        >>> cchecksum("0000000000000000000000000000000000000000", "1234567890abcdef1234567890abcdef12345678")
+        '0x0000000000000000000000000000000000000000'
+
+    See Also:
+        - :func:`eth_utils.to_checksum_address`: A utility function for converting addresses to their checksummed form.
+    """
+    
+    # Declare memoryviews for fixed-length data
+    cdef unsigned char[::1] norm_address_mv = bytearray(norm_address_no_0x.encode('ascii'))
+    cdef unsigned char[::1] hash_bytes_mv = bytearray(address_hash_hex_no_0x.encode('ascii'))
+    
+    # Create a buffer for our result
+    # 2 for "0x" prefix and 40 for the address itself
+    cdef unsigned char[42] buffer = b'0x' + bytearray(40)
+
+    # Handle character casing based on the hash value
+    cdef int i
+    cdef int address_char
+    
+    for i in range(40):
+        address_char = norm_address_mv[i]
+        
+        if hash_bytes_mv[i] < 56:
+            # '0' to '7' have ASCII values 48 to 55
+            buffer[i + 2] = address_char
+            
+        else:
+            # This checks if `norm_char` falls in the ASCII range for lowercase hexadecimal
+            # characters ('a' to 'f'), which correspond to ASCII values 97 to 102. If it does,
+            # the character is capitalized.
+            buffer[i + 2] = address_char - 32 if 97 <= address_char <= 102 else address_char
+
+    # NOTE: For some reason on some systems the buffer length is longer than 42 here, even though that should not be possible.
+    #       Lucky for us, the first 42 characters are always correct. One day maybe I'll debug this.
+    return bytes(buffer[:42]).decode('ascii')

cchecksum/checksum.py

@@ -0,0 +1,111 @@
+import binascii
+from typing import Union
+
+from eth_typing import AnyAddress, ChecksumAddress, HexAddress
+from eth_utils import hexstr_if_str, keccak, to_hex
+from eth_utils.address import _HEX_ADDRESS_REGEXP
+
+from cchecksum._checksum import cchecksum
+
+
+# this was ripped out of eth_utils and optimized a little bit
+
+
+def to_checksum_address(value: Union[AnyAddress, str, bytes]) -> ChecksumAddress:
+    """
+    Convert an address to its EIP-55 checksum format.
+
+    This function takes an address in any supported format and returns it in the
+    checksummed format as defined by EIP-55. It uses a custom Cython implementation
+    for the checksum conversion to optimize performance.
+
+    Args:
+        value: The address to be converted. It can be in any format supported by
+            :func:`eth_utils.to_normalized_address`.
+
+    Raises:
+        ValueError: If the input address is not in a recognized format.
+        TypeError: If the input is not a string, bytes, or any address type.
+
+    Examples:
+        >>> to_checksum_address("0xb47e3cd837ddf8e4c57f05d70ab865de6e193bbb")
+        '0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB'
+
+        >>> to_checksum_address(b'\xb4~<\xd87\xdd\xf8\xe4\xc5\x7f\x05\xd7\n\xb8e\xden\x19;\xbb')
+        '0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB'
+
+    See Also:
+        - :func:`eth_utils.to_checksum_address` for the standard implementation.
+        - :func:`to_normalized_address` for converting to a normalized address before checksumming.
+    """
+    norm_address_no_0x = to_normalized_address(value)[2:]
+    address_hash = keccak(text=norm_address_no_0x)
+    address_hash_hex_no_0x = binascii.hexlify(address_hash).decode("ascii")
+    return cchecksum(norm_address_no_0x, address_hash_hex_no_0x)
+
+
+def to_normalized_address(value: Union[AnyAddress, str, bytes]) -> HexAddress:
+    """
+    Converts an address to its normalized hexadecimal representation.
+
+    This function ensures that the address is in a consistent lowercase hexadecimal
+    format, which is useful for further processing or validation. It uses
+    :func:`eth_utils.hexstr_if_str` and :func:`eth_utils.to_hex` to convert the input
+    to a hexadecimal string.
+
+    Args:
+        value: The address to be normalized. It can be in any format supported by
+            :func:`eth_utils.to_hex`.
+
+    Raises:
+        ValueError: If the input address is not in a recognized format.
+        TypeError: If the input is not a string, bytes, or any address type.
+
+    Examples:
+        >>> to_normalized_address("0xB47E3CD837DDF8E4C57F05D70AB865DE6E193BBB")
+        '0xb47e3cd837ddf8e4c57f05d70ab865de6e193bbb'
+
+        >>> to_normalized_address(b'\xb4~<\xd87\xdd\xf8\xe4\xc5\x7f\x05\xd7\n\xb8e\xden\x19;\xbb')
+        '0xb47e3cd837ddf8e4c57f05d70ab865de6e193bbb'
+
+    See Also:
+        - :func:`eth_utils.to_normalized_address` for the standard implementation.
+        - :func:`is_address` for checking if a string is a valid address.
+    """
+    try:
+        hex_address = hexstr_if_str(to_hex, value).lower()
+    except AttributeError:
+        raise TypeError(f"Value must be any string, instead got type {type(value)}")
+
+    if not is_address(hex_address):
+        raise ValueError(
+            f"Unknown format {repr(value)}, attempted to normalize to {repr(hex_address)}"
+        )
+
+    return hex_address  # type: ignore [return-value]
+
+
+def is_address(value: str) -> bool:
+    """
+    Check if the given string is a valid address in any known format.
+
+    This function uses a regular expression to determine if the input string
+    matches the expected pattern for a hexadecimal address.
+
+    Args:
+        value: The string to be checked.
+
+    Returns:
+        True if the string is a valid address, False otherwise.
+
+    Examples:
+        >>> is_address("0xb47e3cd837ddf8e4c57f05d70ab865de6e193bbb")
+        True
+
+        >>> is_address("not-an-address")
+        False
+
+    See Also:
+        - :func:`eth_utils.is_address` for the standard implementation.
+    """
+    return _HEX_ADDRESS_REGEXP.fullmatch(value) is not None

cchecksum-0.0.1.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: cchecksum
+Version: 0.0.1
+Summary: A ~2x faster drop-in replacement for eth_utils.to_checksum_address. Raises the exact same Exceptions. Implemented in C.
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12

cchecksum-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+cchecksum/__init__.py,sha256=9-zGSD00qMygcrDHsETJUjNxiEez2yfWTKevEdAV2aU,84
+cchecksum/_cchecksum.pyi,sha256=W_5hkOKIW7HMcNQEvtWd3hBq7NQSsLpirjvC5bnNuYw,134
+cchecksum/_checksum.pyx,sha256=G65TQEozxbVTq9AgSKLLA9xfjmCl8AwbZYoFrJyvS3U,2459
+cchecksum/checksum.py,sha256=YvnNt8Sg2-sqoeQfJTSnu1vxlM03-TIwUaQUP9asWGw,4039
+cchecksum/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cchecksum-0.0.1.dist-info/METADATA,sha256=HHfHEFzwrTqX6JKy3qIGGYblld4bkz11ah7cETN0rVk,781
+cchecksum-0.0.1.dist-info/WHEEL,sha256=IrRNNNJ-uuL1ggO5qMvT1GGhQVdQU54d6ZpYqEZfEWo,92
+cchecksum-0.0.1.dist-info/RECORD,,

cchecksum-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py2.py3-none-any