cchecksum 0.0.7__tar.gz → 0.0.9__tar.gz

{cchecksum-0.0.7 → cchecksum-0.0.9}/.github/workflows/deploy-docs.yaml

@@ -5,15 +5,21 @@ on:
     branches:
       - master
 
+
 # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
 permissions:
   contents: write
   id-token: write
   pages: write
+
   
 jobs:
   build-and-deploy:
     runs-on: ubuntu-latest
+    
+    environment:
+      name: github-pages
+      
     steps:
       - name: Check out code
         uses: actions/checkout@v2

{cchecksum-0.0.7 → cchecksum-0.0.9}/.github/workflows/release.yaml

@@ -8,7 +8,7 @@ on:
 
 jobs:
   deploy:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
 
     steps:
     - uses: actions/checkout@v2

{cchecksum-0.0.7/cchecksum.egg-info → cchecksum-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: cchecksum
-Version: 0.0.7
+Version: 0.0.9
 Summary: A ~2x faster drop-in replacement for eth_utils.to_checksum_address. Raises the exact same Exceptions. Implemented in C.
 Home-page: https://github.com/BobTheBuidler/cchecksum
 Author: BobTheBuidler
@@ -15,6 +15,7 @@ Dynamic: author
 Dynamic: author-email
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{cchecksum-0.0.7 → cchecksum-0.0.9}/cchecksum/_checksum.c

@@ -2903,7 +2903,7 @@ static int __Pyx_ValidateAndInit_memviewslice(
                 PyObject *original_obj);
 
 /* ObjectToMemviewSlice.proto */
-static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_unsigned_char(PyObject *, int writable_flag);
+static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_unsigned_char__const__(PyObject *, int writable_flag);
 
 /* MemviewSliceCopyTemplate.proto */
 static __Pyx_memviewslice
@@ -3034,7 +3034,7 @@ static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size
 static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/
 static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/
 /* #### Code section: typeinfo ### */
-static __Pyx_TypeInfo __Pyx_TypeInfo_unsigned_char = { "unsigned char", NULL, sizeof(unsigned char), { 0 }, 0, __PYX_IS_UNSIGNED(unsigned char) ? 'U' : 'I', __PYX_IS_UNSIGNED(unsigned char), 0 };
+static __Pyx_TypeInfo __Pyx_TypeInfo_unsigned_char__const__ = { "const unsigned char", NULL, sizeof(unsigned char const ), { 0 }, 0, __PYX_IS_UNSIGNED(unsigned char const ) ? 'U' : 'I', __PYX_IS_UNSIGNED(unsigned char const ), 0 };
 /* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "cchecksum._checksum"
 extern int __pyx_module_is_main_cchecksum___checksum;
@@ -3137,7 +3137,6 @@ static const char __pyx_k_stringsource[] = "<stringsource>";
 static const char __pyx_k_version_info[] = "version_info";
 static const char __pyx_k_OverflowError[] = "OverflowError";
 static const char __pyx_k_class_getitem[] = "__class_getitem__";
-static const char __pyx_k_hash_bytes_mv[] = "hash_bytes_mv";
 static const char __pyx_k_reduce_cython[] = "__reduce_cython__";
 static const char __pyx_k_AssertionError[] = "AssertionError";
 static const char __pyx_k_View_MemoryView[] = "View.MemoryView";
@@ -3169,7 +3168,7 @@ static const char __pyx_k_Step_may_not_be_zero_axis_d[] = "Step may not be zero
 static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array";
 static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data.";
 static const char __pyx_k_strided_and_direct_or_indirect[] = "<strided and direct or indirect>";
-static const char __pyx_k_Computes_the_checksummed_versio[] = "\n    Computes the checksummed version of an Ethereum address.\n\n    This function takes a normalized Ethereum address (without the '0x' prefix) and its corresponding\n    hash (also without the '0x' prefix) and returns the checksummed address as per the Ethereum\n    Improvement Proposal 55 (EIP-55).\n\n    Args:\n        norm_address_no_0x (str): The normalized Ethereum address without the '0x' prefix.\n        address_hash_hex_no_0x (str): The hash of the address, also without the '0x' prefix.\n\n    Returns:\n        The checksummed Ethereum address with the '0x' prefix.\n\n    Examples:\n        >>> cchecksum(\"b47e3cd837ddf8e4c57f05d70ab865de6e193bbb\", \"abcdef1234567890abcdef1234567890abcdef12\")\n        '0xB47E3Cd837DdF8E4C57F05D70Ab865De6E193BbB'\n\n        >>> cchecksum(\"0000000000000000000000000000000000000000\", \"1234567890abcdef1234567890abcdef12345678\")\n        '0x0000000000000000000000000000000000000000'\n\n    See Also:\n        - :func:`eth_utils.to_checksum_address`: A utility function for converting addresses to their checksummed form.\n    ";
+static const char __pyx_k_Computes_the_checksummed_versio[] = "\n    Computes the checksummed version of an Ethereum address.\n\n    This function takes a normalized Ethereum address (without the '0x' prefix) and its corresponding\n    hash (also without the '0x' prefix) and returns the checksummed address as per the Ethereum\n    Improvement Proposal 55 (EIP-55).\n\n    Args:\n        norm_address_no_0x (str): The normalized Ethereum address without the '0x' prefix.\n        address_hash_hex_no_0x (bytes): The hash of the address, also without the '0x' prefix.\n\n    Returns:\n        The checksummed Ethereum address with the '0x' prefix.\n\n    Examples:\n        >>> cchecksum(\"b47e3cd837ddf8e4c57f05d70ab865de6e193bbb\", \"abcdef1234567890abcdef1234567890abcdef12\")\n        '0xB47E3Cd837DdF8E4C57F05D70Ab865De6E193BbB'\n\n        >>> cchecksum(\"0000000000000000000000000000000000000000\", \"1234567890abcdef1234567890abcdef12345678\")\n        '0x0000000000000000000000000000000000000000'\n\n    See Also:\n        - :func:`eth_utils.to_checksum_address`: A utility function for converting addresses to their checksummed form.\n    ";
 static const char __pyx_k_All_dimensions_preceding_dimensi[] = "All dimensions preceding dimension %d must be indexed and not sliced";
 static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides";
 static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory.";
@@ -3227,7 +3226,7 @@ static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewsl
 static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */
 static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */
-static PyObject *__pyx_pf_9cchecksum_9_checksum_cchecksum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_norm_address_no_0x, PyObject *__pyx_v_address_hash_hex_no_0x); /* proto */
+static PyObject *__pyx_pf_9cchecksum_9_checksum_cchecksum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_norm_address_no_0x, __Pyx_memviewslice __pyx_v_address_hash_hex_no_0x); /* proto */
 static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
 static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
 static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
@@ -3345,7 +3344,6 @@ typedef struct {
   PyObject *__pyx_n_s_getstate;
   PyObject *__pyx_kp_u_got;
   PyObject *__pyx_kp_u_got_differing_extents_in_dimensi;
-  PyObject *__pyx_n_s_hash_bytes_mv;
   PyObject *__pyx_n_s_i;
   PyObject *__pyx_n_s_id;
   PyObject *__pyx_n_s_import;
@@ -3553,7 +3551,6 @@ static int __pyx_m_clear(PyObject *m) {
   Py_CLEAR(clear_module_state->__pyx_n_s_getstate);
   Py_CLEAR(clear_module_state->__pyx_kp_u_got);
   Py_CLEAR(clear_module_state->__pyx_kp_u_got_differing_extents_in_dimensi);
-  Py_CLEAR(clear_module_state->__pyx_n_s_hash_bytes_mv);
   Py_CLEAR(clear_module_state->__pyx_n_s_i);
   Py_CLEAR(clear_module_state->__pyx_n_s_id);
   Py_CLEAR(clear_module_state->__pyx_n_s_import);
@@ -3739,7 +3736,6 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
   Py_VISIT(traverse_module_state->__pyx_n_s_getstate);
   Py_VISIT(traverse_module_state->__pyx_kp_u_got);
   Py_VISIT(traverse_module_state->__pyx_kp_u_got_differing_extents_in_dimensi);
-  Py_VISIT(traverse_module_state->__pyx_n_s_hash_bytes_mv);
   Py_VISIT(traverse_module_state->__pyx_n_s_i);
   Py_VISIT(traverse_module_state->__pyx_n_s_id);
   Py_VISIT(traverse_module_state->__pyx_n_s_import);
@@ -3935,7 +3931,6 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
 #define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate
 #define __pyx_kp_u_got __pyx_mstate_global->__pyx_kp_u_got
 #define __pyx_kp_u_got_differing_extents_in_dimensi __pyx_mstate_global->__pyx_kp_u_got_differing_extents_in_dimensi
-#define __pyx_n_s_hash_bytes_mv __pyx_mstate_global->__pyx_n_s_hash_bytes_mv
 #define __pyx_n_s_i __pyx_mstate_global->__pyx_n_s_i
 #define __pyx_n_s_id __pyx_mstate_global->__pyx_n_s_id
 #define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import
@@ -18007,7 +18002,7 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__
 /* "cchecksum/_checksum.pyx":3
  * # cython: boundscheck=False
  * 
- * def cchecksum(str norm_address_no_0x, str address_hash_hex_no_0x) -> str:             # <<<<<<<<<<<<<<
+ * def cchecksum(str norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str:             # <<<<<<<<<<<<<<
  *     """
  *     Computes the checksummed version of an Ethereum address.
  */
@@ -18020,7 +18015,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
 PyObject *__pyx_args, PyObject *__pyx_kwds
 #endif
 ); /*proto*/
-PyDoc_STRVAR(__pyx_doc_9cchecksum_9_checksum_cchecksum, "cchecksum(unicode norm_address_no_0x, unicode address_hash_hex_no_0x) -> str\n\n    Computes the checksummed version of an Ethereum address.\n\n    This function takes a normalized Ethereum address (without the '0x' prefix) and its corresponding\n    hash (also without the '0x' prefix) and returns the checksummed address as per the Ethereum\n    Improvement Proposal 55 (EIP-55).\n\n    Args:\n        norm_address_no_0x (str): The normalized Ethereum address without the '0x' prefix.\n        address_hash_hex_no_0x (str): The hash of the address, also without the '0x' prefix.\n\n    Returns:\n        The checksummed Ethereum address with the '0x' prefix.\n\n    Examples:\n        >>> cchecksum(\"b47e3cd837ddf8e4c57f05d70ab865de6e193bbb\", \"abcdef1234567890abcdef1234567890abcdef12\")\n        '0xB47E3Cd837DdF8E4C57F05D70Ab865De6E193BbB'\n\n        >>> cchecksum(\"0000000000000000000000000000000000000000\", \"1234567890abcdef1234567890abcdef12345678\")\n        '0x0000000000000000000000000000000000000000'\n\n    See Also:\n        - :func:`eth_utils.to_checksum_address`: A utility function for converting addresses to their checksummed form.\n    ");
+PyDoc_STRVAR(__pyx_doc_9cchecksum_9_checksum_cchecksum, "cchecksum(unicode norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str\n\n    Computes the checksummed version of an Ethereum address.\n\n    This function takes a normalized Ethereum address (without the '0x' prefix) and its corresponding\n    hash (also without the '0x' prefix) and returns the checksummed address as per the Ethereum\n    Improvement Proposal 55 (EIP-55).\n\n    Args:\n        norm_address_no_0x (str): The normalized Ethereum address without the '0x' prefix.\n        address_hash_hex_no_0x (bytes): The hash of the address, also without the '0x' prefix.\n\n    Returns:\n        The checksummed Ethereum address with the '0x' prefix.\n\n    Examples:\n        >>> cchecksum(\"b47e3cd837ddf8e4c57f05d70ab865de6e193bbb\", \"abcdef1234567890abcdef1234567890abcdef12\")\n        '0xB47E3Cd837DdF8E4C57F05D70Ab865De6E193BbB'\n\n        >>> cchecksum(\"0000000000000000000000000000000000000000\", \"1234567890abcdef1234567890abcdef12345678\")\n        '0x0000000000000000000000000000000000000000'\n\n    See Also:\n        - :func:`eth_utils.to_checksum_address`: A utility function for converting addresses to their checksummed form.\n    ");
 static PyMethodDef __pyx_mdef_9cchecksum_9_checksum_1cchecksum = {"cchecksum", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9cchecksum_9_checksum_1cchecksum, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9cchecksum_9_checksum_cchecksum};
 static PyObject *__pyx_pw_9cchecksum_9_checksum_1cchecksum(PyObject *__pyx_self, 
 #if CYTHON_METH_FASTCALL
@@ -18030,7 +18025,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds
 #endif
 ) {
   PyObject *__pyx_v_norm_address_no_0x = 0;
-  PyObject *__pyx_v_address_hash_hex_no_0x = 0;
+  __Pyx_memviewslice __pyx_v_address_hash_hex_no_0x = { 0, 0, { 0 }, { 0 }, { 0 } };
   #if !CYTHON_METH_FASTCALL
   CYTHON_UNUSED Py_ssize_t __pyx_nargs;
   #endif
@@ -18093,7 +18088,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds
       values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_norm_address_no_0x = ((PyObject*)values[0]);
-    __pyx_v_address_hash_hex_no_0x = ((PyObject*)values[1]);
+    __pyx_v_address_hash_hex_no_0x = __Pyx_PyObject_to_MemoryviewSlice_dc_unsigned_char__const__(values[1], 0); if (unlikely(!__pyx_v_address_hash_hex_no_0x.memview)) __PYX_ERR(0, 3, __pyx_L3_error)
   }
   goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
@@ -18107,12 +18102,12 @@ PyObject *__pyx_args, PyObject *__pyx_kwds
       __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
     }
   }
+  __PYX_XCLEAR_MEMVIEW(&__pyx_v_address_hash_hex_no_0x, 1);
   __Pyx_AddTraceback("cchecksum._checksum.cchecksum", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
   if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_norm_address_no_0x), (&PyUnicode_Type), 1, "norm_address_no_0x", 1))) __PYX_ERR(0, 3, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_address_hash_hex_no_0x), (&PyUnicode_Type), 1, "address_hash_hex_no_0x", 1))) __PYX_ERR(0, 3, __pyx_L1_error)
   __pyx_r = __pyx_pf_9cchecksum_9_checksum_cchecksum(__pyx_self, __pyx_v_norm_address_no_0x, __pyx_v_address_hash_hex_no_0x);
 
   /* function exit code */
@@ -18120,6 +18115,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds
   __pyx_L1_error:;
   __pyx_r = NULL;
   __pyx_L0:;
+  __PYX_XCLEAR_MEMVIEW(&__pyx_v_address_hash_hex_no_0x, 1);
   {
     Py_ssize_t __pyx_temp;
     for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
@@ -18130,9 +18126,8 @@ PyObject *__pyx_args, PyObject *__pyx_kwds
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_9cchecksum_9_checksum_cchecksum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_norm_address_no_0x, PyObject *__pyx_v_address_hash_hex_no_0x) {
+static PyObject *__pyx_pf_9cchecksum_9_checksum_cchecksum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_norm_address_no_0x, __Pyx_memviewslice __pyx_v_address_hash_hex_no_0x) {
   __Pyx_memviewslice __pyx_v_norm_address_mv = { 0, 0, { 0 }, { 0 }, { 0 } };
-  __Pyx_memviewslice __pyx_v_hash_bytes_mv = { 0, 0, { 0 }, { 0 }, { 0 } };
   unsigned char __pyx_v_buffer[42];
   int __pyx_v_i;
   int __pyx_v_address_char;
@@ -18140,8 +18135,8 @@ static PyObject *__pyx_pf_9cchecksum_9_checksum_cchecksum(CYTHON_UNUSED PyObject
   __Pyx_TraceDeclarations
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  __Pyx_memviewslice __pyx_t_3 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } };
+  PyObject *__pyx_t_3 = NULL;
   unsigned char __pyx_t_4[42];
   int __pyx_t_5;
   Py_ssize_t __pyx_t_6;
@@ -18157,9 +18152,9 @@ static PyObject *__pyx_pf_9cchecksum_9_checksum_cchecksum(CYTHON_UNUSED PyObject
   /* "cchecksum/_checksum.pyx":30
  * 
  *     # 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'))
+ *     cdef const unsigned char[::1] norm_address_mv = norm_address_no_0x.encode('ascii')             # <<<<<<<<<<<<<<
  * 
+ *     # Create a buffer for our result
  */
   __Pyx_TraceLine(30,0,__PYX_ERR(0, 30, __pyx_L1_error))
   if (unlikely(__pyx_v_norm_address_no_0x == Py_None)) {
@@ -18168,120 +18163,96 @@ static PyObject *__pyx_pf_9cchecksum_9_checksum_cchecksum(CYTHON_UNUSED PyObject
   }
   __pyx_t_1 = PyUnicode_AsASCIIString(__pyx_v_norm_address_no_0x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyByteArray_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 30, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_dc_unsigned_char(__pyx_t_2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 30, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_norm_address_mv = __pyx_t_3;
-  __pyx_t_3.memview = NULL;
-  __pyx_t_3.data = NULL;
-
-  /* "cchecksum/_checksum.pyx":31
- *     # 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
- */
-  __Pyx_TraceLine(31,0,__PYX_ERR(0, 31, __pyx_L1_error))
-  if (unlikely(__pyx_v_address_hash_hex_no_0x == Py_None)) {
-    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode");
-    __PYX_ERR(0, 31, __pyx_L1_error)
-  }
-  __pyx_t_2 = PyUnicode_AsASCIIString(__pyx_v_address_hash_hex_no_0x); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 31, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyByteArray_Type)), __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_dc_unsigned_char(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 31, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dc_unsigned_char__const__(__pyx_t_1, 0); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 30, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_v_hash_bytes_mv = __pyx_t_3;
-  __pyx_t_3.memview = NULL;
-  __pyx_t_3.data = NULL;
+  __pyx_v_norm_address_mv = __pyx_t_2;
+  __pyx_t_2.memview = NULL;
+  __pyx_t_2.data = NULL;
 
-  /* "cchecksum/_checksum.pyx":35
+  /* "cchecksum/_checksum.pyx":34
  *     # 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
  */
-  __Pyx_TraceLine(35,0,__PYX_ERR(0, 35, __pyx_L1_error))
-  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyByteArray_Type)), __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 35, __pyx_L1_error)
+  __Pyx_TraceLine(34,0,__PYX_ERR(0, 34, __pyx_L1_error))
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyByteArray_Type)), __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyNumber_Add(__pyx_kp_b_0x, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyNumber_Add(__pyx_kp_b_0x, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely((__Pyx_carray_from_py_unsigned_char(__pyx_t_2, __pyx_t_4, 42) < 0))) __PYX_ERR(0, 35, __pyx_L1_error)
+  if (unlikely((__Pyx_carray_from_py_unsigned_char(__pyx_t_3, __pyx_t_4, 42) < 0))) __PYX_ERR(0, 34, __pyx_L1_error)
   memcpy(&(__pyx_v_buffer[0]), __pyx_t_4, sizeof(__pyx_v_buffer[0]) * (42));
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  /* "cchecksum/_checksum.pyx":41
+  /* "cchecksum/_checksum.pyx":40
  *     cdef int address_char
  * 
  *     for i in range(40):             # <<<<<<<<<<<<<<
- *         address_char = norm_address_mv[i]
  * 
+ *         if address_hash_hex_no_0x[i] < 56:
  */
-  __Pyx_TraceLine(41,0,__PYX_ERR(0, 41, __pyx_L1_error))
+  __Pyx_TraceLine(40,0,__PYX_ERR(0, 40, __pyx_L1_error))
   for (__pyx_t_5 = 0; __pyx_t_5 < 40; __pyx_t_5+=1) {
     __pyx_v_i = __pyx_t_5;
 
     /* "cchecksum/_checksum.pyx":42
- * 
  *     for i in range(40):
- *         address_char = norm_address_mv[i]             # <<<<<<<<<<<<<<
- * 
- *         if hash_bytes_mv[i] < 56:
- */
-    __Pyx_TraceLine(42,0,__PYX_ERR(0, 42, __pyx_L1_error))
-    __pyx_t_6 = __pyx_v_i;
-    if (__pyx_t_6 < 0) __pyx_t_6 += __pyx_v_norm_address_mv.shape[0];
-    __pyx_v_address_char = (*((unsigned char *) ( /* dim=0 */ ((char *) (((unsigned char *) __pyx_v_norm_address_mv.data) + __pyx_t_6)) )));
-
-    /* "cchecksum/_checksum.pyx":44
- *         address_char = norm_address_mv[i]
  * 
- *         if hash_bytes_mv[i] < 56:             # <<<<<<<<<<<<<<
+ *         if address_hash_hex_no_0x[i] < 56:             # <<<<<<<<<<<<<<
  *             # '0' to '7' have ASCII values 48 to 55
- *             buffer[i + 2] = address_char
+ *             buffer[i + 2] = norm_address_mv[i]
  */
-    __Pyx_TraceLine(44,0,__PYX_ERR(0, 44, __pyx_L1_error))
+    __Pyx_TraceLine(42,0,__PYX_ERR(0, 42, __pyx_L1_error))
     __pyx_t_6 = __pyx_v_i;
-    if (__pyx_t_6 < 0) __pyx_t_6 += __pyx_v_hash_bytes_mv.shape[0];
-    __pyx_t_7 = ((*((unsigned char *) ( /* dim=0 */ ((char *) (((unsigned char *) __pyx_v_hash_bytes_mv.data) + __pyx_t_6)) ))) < 56);
+    if (__pyx_t_6 < 0) __pyx_t_6 += __pyx_v_address_hash_hex_no_0x.shape[0];
+    __pyx_t_7 = ((*((unsigned char const  *) ( /* dim=0 */ ((char *) (((unsigned char const  *) __pyx_v_address_hash_hex_no_0x.data) + __pyx_t_6)) ))) < 56);
     if (__pyx_t_7) {
 
-      /* "cchecksum/_checksum.pyx":46
- *         if hash_bytes_mv[i] < 56:
+      /* "cchecksum/_checksum.pyx":44
+ *         if address_hash_hex_no_0x[i] < 56:
  *             # '0' to '7' have ASCII values 48 to 55
- *             buffer[i + 2] = address_char             # <<<<<<<<<<<<<<
+ *             buffer[i + 2] = norm_address_mv[i]             # <<<<<<<<<<<<<<
  * 
  *         else:
  */
-      __Pyx_TraceLine(46,0,__PYX_ERR(0, 46, __pyx_L1_error))
-      (__pyx_v_buffer[(__pyx_v_i + 2)]) = __pyx_v_address_char;
+      __Pyx_TraceLine(44,0,__PYX_ERR(0, 44, __pyx_L1_error))
+      __pyx_t_6 = __pyx_v_i;
+      if (__pyx_t_6 < 0) __pyx_t_6 += __pyx_v_norm_address_mv.shape[0];
+      (__pyx_v_buffer[(__pyx_v_i + 2)]) = (*((unsigned char const  *) ( /* dim=0 */ ((char *) (((unsigned char const  *) __pyx_v_norm_address_mv.data) + __pyx_t_6)) )));
 
-      /* "cchecksum/_checksum.pyx":44
- *         address_char = norm_address_mv[i]
+      /* "cchecksum/_checksum.pyx":42
+ *     for i in range(40):
  * 
- *         if hash_bytes_mv[i] < 56:             # <<<<<<<<<<<<<<
+ *         if address_hash_hex_no_0x[i] < 56:             # <<<<<<<<<<<<<<
  *             # '0' to '7' have ASCII values 48 to 55
- *             buffer[i + 2] = address_char
+ *             buffer[i + 2] = norm_address_mv[i]
  */
       goto __pyx_L5;
     }
 
-    /* "cchecksum/_checksum.pyx":52
+    /* "cchecksum/_checksum.pyx":47
+ * 
+ *         else:
+ *             address_char = norm_address_mv[i]             # <<<<<<<<<<<<<<
+ *             # This checks if `address_char` falls in the ASCII range for lowercase hexadecimal
+ *             # characters ('a' to 'f'), which correspond to ASCII values 97 to 102. If it does,
+ */
+    __Pyx_TraceLine(47,0,__PYX_ERR(0, 47, __pyx_L1_error))
+    /*else*/ {
+      __pyx_t_6 = __pyx_v_i;
+      if (__pyx_t_6 < 0) __pyx_t_6 += __pyx_v_norm_address_mv.shape[0];
+      __pyx_v_address_char = (*((unsigned char const  *) ( /* dim=0 */ ((char *) (((unsigned char const  *) __pyx_v_norm_address_mv.data) + __pyx_t_6)) )));
+
+      /* "cchecksum/_checksum.pyx":51
  *             # 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.
  */
-    __Pyx_TraceLine(52,0,__PYX_ERR(0, 52, __pyx_L1_error))
-    /*else*/ {
+      __Pyx_TraceLine(51,0,__PYX_ERR(0, 51, __pyx_L1_error))
       __pyx_t_7 = (97 <= __pyx_v_address_char);
       if (__pyx_t_7) {
         __pyx_t_7 = (__pyx_v_address_char <= 0x66);
@@ -18296,29 +18267,29 @@ static PyObject *__pyx_pf_9cchecksum_9_checksum_cchecksum(CYTHON_UNUSED PyObject
     __pyx_L5:;
   }
 
-  /* "cchecksum/_checksum.pyx":56
+  /* "cchecksum/_checksum.pyx":55
  *     # 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')             # <<<<<<<<<<<<<<
  */
-  __Pyx_TraceLine(56,0,__PYX_ERR(0, 56, __pyx_L1_error))
+  __Pyx_TraceLine(55,0,__PYX_ERR(0, 55, __pyx_L1_error))
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(((const char*)__pyx_v_buffer) + 0, 42 - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyBytes_FromStringAndSize(((const char*)__pyx_v_buffer) + 0, 42 - 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_decode_bytes(__pyx_t_1, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_decode_bytes(__pyx_t_1, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = ((PyObject*)__pyx_t_2);
-  __pyx_t_2 = 0;
+  __pyx_r = ((PyObject*)__pyx_t_3);
+  __pyx_t_3 = 0;
   goto __pyx_L0;
 
   /* "cchecksum/_checksum.pyx":3
  * # cython: boundscheck=False
  * 
- * def cchecksum(str norm_address_no_0x, str address_hash_hex_no_0x) -> str:             # <<<<<<<<<<<<<<
+ * def cchecksum(str norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str:             # <<<<<<<<<<<<<<
  *     """
  *     Computes the checksummed version of an Ethereum address.
  */
@@ -18326,13 +18297,12 @@ static PyObject *__pyx_pf_9cchecksum_9_checksum_cchecksum(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __PYX_XCLEAR_MEMVIEW(&__pyx_t_3, 1);
+  __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1);
+  __Pyx_XDECREF(__pyx_t_3);
   __Pyx_AddTraceback("cchecksum._checksum.cchecksum", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __PYX_XCLEAR_MEMVIEW(&__pyx_v_norm_address_mv, 1);
-  __PYX_XCLEAR_MEMVIEW(&__pyx_v_hash_bytes_mv, 1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_TraceReturn(__pyx_r, 0);
   __Pyx_RefNannyFinishContext();
@@ -19389,7 +19359,6 @@ static int __Pyx_CreateStringTabAndInitStrings(void) {
     {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1},
     {&__pyx_kp_u_got, __pyx_k_got, sizeof(__pyx_k_got), 0, 1, 0, 0},
     {&__pyx_kp_u_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 1, 0, 0},
-    {&__pyx_n_s_hash_bytes_mv, __pyx_k_hash_bytes_mv, sizeof(__pyx_k_hash_bytes_mv), 0, 0, 1, 1},
     {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1},
     {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1},
     {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
@@ -19452,7 +19421,7 @@ static int __Pyx_CreateStringTabAndInitStrings(void) {
 }
 /* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
-  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 41, __pyx_L1_error)
+  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 40, __pyx_L1_error)
   __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 83, __pyx_L1_error)
   __pyx_builtin_OverflowError = __Pyx_GetBuiltinName(__pyx_n_s_OverflowError); if (!__pyx_builtin_OverflowError) __PYX_ERR(1, 83, __pyx_L1_error)
   __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 86, __pyx_L1_error)
@@ -19509,14 +19478,14 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_GOTREF(__pyx_tuple__8);
   __Pyx_GIVEREF(__pyx_tuple__8);
 
-  /* "cchecksum/_checksum.pyx":35
+  /* "cchecksum/_checksum.pyx":34
  *     # 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
  */
-  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_int_40); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 35, __pyx_L1_error)
+  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_int_40); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 34, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__10);
   __Pyx_GIVEREF(__pyx_tuple__10);
 
@@ -19624,14 +19593,14 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   /* "cchecksum/_checksum.pyx":3
  * # cython: boundscheck=False
  * 
- * def cchecksum(str norm_address_no_0x, str address_hash_hex_no_0x) -> str:             # <<<<<<<<<<<<<<
+ * def cchecksum(str norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str:             # <<<<<<<<<<<<<<
  *     """
  *     Computes the checksummed version of an Ethereum address.
  */
-  __pyx_tuple__22 = PyTuple_Pack(7, __pyx_n_s_norm_address_no_0x, __pyx_n_s_address_hash_hex_no_0x, __pyx_n_s_norm_address_mv, __pyx_n_s_hash_bytes_mv, __pyx_n_s_buffer, __pyx_n_s_i, __pyx_n_s_address_char); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __pyx_tuple__22 = PyTuple_Pack(6, __pyx_n_s_norm_address_no_0x, __pyx_n_s_address_hash_hex_no_0x, __pyx_n_s_norm_address_mv, __pyx_n_s_buffer, __pyx_n_s_i, __pyx_n_s_address_char); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 3, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__22);
   __Pyx_GIVEREF(__pyx_tuple__22);
-  __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cchecksum__checksum_pyx, __pyx_n_s_cchecksum, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cchecksum__checksum_pyx, __pyx_n_s_cchecksum, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 3, __pyx_L1_error)
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
@@ -20698,7 +20667,7 @@ if (!__Pyx_RefNanny) {
   /* "cchecksum/_checksum.pyx":3
  * # cython: boundscheck=False
  * 
- * def cchecksum(str norm_address_no_0x, str address_hash_hex_no_0x) -> str:             # <<<<<<<<<<<<<<
+ * def cchecksum(str norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str:             # <<<<<<<<<<<<<<
  *     """
  *     Computes the checksummed version of an Ethereum address.
  */
@@ -20716,7 +20685,7 @@ if (!__Pyx_RefNanny) {
   /* "cchecksum/_checksum.pyx":1
  * # cython: boundscheck=False             # <<<<<<<<<<<<<<
  * 
- * def cchecksum(str norm_address_no_0x, str address_hash_hex_no_0x) -> str:
+ * def cchecksum(str norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str:
  */
   __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error))
   __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1, __pyx_L1_error)
@@ -26271,7 +26240,7 @@ no_fail:
 }
 
 /* ObjectToMemviewSlice */
-  static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_unsigned_char(PyObject *obj, int writable_flag) {
+  static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_unsigned_char__const__(PyObject *obj, int writable_flag) {
     __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } };
     __Pyx_BufFmt_StackElem stack[1];
     int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) };
@@ -26282,7 +26251,7 @@ no_fail:
     }
     retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG,
                                                  (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 1,
-                                                 &__Pyx_TypeInfo_unsigned_char, stack,
+                                                 &__Pyx_TypeInfo_unsigned_char__const__, stack,
                                                  &result, obj);
     if (unlikely(retcode == -1))
         goto __pyx_fail;

cchecksum-0.0.9/cchecksum/_checksum.pyi

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

{cchecksum-0.0.7 → cchecksum-0.0.9}/cchecksum/_checksum.pyx

@@ -1,6 +1,6 @@
 # cython: boundscheck=False
 
-def cchecksum(str norm_address_no_0x, str address_hash_hex_no_0x) -> str:
+def cchecksum(str norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str:
     """
     Computes the checksummed version of an Ethereum address.
 
@@ -10,7 +10,7 @@ def cchecksum(str norm_address_no_0x, str address_hash_hex_no_0x) -> str:
 
     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.
+        address_hash_hex_no_0x (bytes): The hash of the address, also without the '0x' prefix.
 
     Returns:
         The checksummed Ethereum address with the '0x' prefix.
@@ -27,8 +27,7 @@ def cchecksum(str norm_address_no_0x, str address_hash_hex_no_0x) -> str:
     """
     
     # 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'))
+    cdef const unsigned char[::1] norm_address_mv = norm_address_no_0x.encode('ascii')
     
     # Create a buffer for our result
     # 2 for "0x" prefix and 40 for the address itself
@@ -39,14 +38,14 @@ def cchecksum(str norm_address_no_0x, str address_hash_hex_no_0x) -> str:
     cdef int address_char
     
     for i in range(40):
-        address_char = norm_address_mv[i]
         
-        if hash_bytes_mv[i] < 56:
+        if address_hash_hex_no_0x[i] < 56:
             # '0' to '7' have ASCII values 48 to 55
-            buffer[i + 2] = address_char
+            buffer[i + 2] = norm_address_mv[i]
             
         else:
-            # This checks if `norm_char` falls in the ASCII range for lowercase hexadecimal
+            address_char = norm_address_mv[i]
+            # This checks if `address_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

{cchecksum-0.0.7 → cchecksum-0.0.9}/cchecksum/checksum.py

@@ -3,12 +3,24 @@ from typing import Optional, Union
 
 from eth_hash.auto import keccak
 from eth_typing import AnyAddress, ChecksumAddress, HexAddress, HexStr, Primitives
-from eth_utils import add_0x_prefix, encode_hex, hexstr_if_str
+from eth_utils import encode_hex, hexstr_if_str
 from eth_utils.address import _HEX_ADDRESS_REGEXP
+from eth_utils.toolz import compose
 
 from cchecksum._checksum import cchecksum
 
 
+BytesLike = Union[Primitives, bytearray, memoryview]
+
+
+# force _hasher_first_run and _preimage_first_run to execute so we can cache the new hasher
+keccak(b"")
+
+hash_address = compose(hexlify, bytes, keccak.hasher, str.encode)
+
+hex_address_fullmatch = _HEX_ADDRESS_REGEXP.fullmatch
+
+
 # this was ripped out of eth_utils and optimized a little bit
 
 
@@ -40,9 +52,7 @@ def to_checksum_address(value: Union[AnyAddress, str, bytes]) -> ChecksumAddress
         - :func:`to_normalized_address` for converting to a normalized address before checksumming.
     """
     norm_address_no_0x = to_normalized_address(value)[2:]
-    address_hash = bytes(keccak(norm_address_no_0x.encode("utf-8")))
-    address_hash_hex_no_0x = hexlify(address_hash).decode("ascii")
-    return cchecksum(norm_address_no_0x, address_hash_hex_no_0x)
+    return cchecksum(norm_address_no_0x, hash_address(norm_address_no_0x))
 
 
 def to_normalized_address(value: Union[AnyAddress, str, bytes]) -> HexAddress:
@@ -75,10 +85,13 @@ def to_normalized_address(value: Union[AnyAddress, str, bytes]) -> HexAddress:
     """
     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)}")
+    except AttributeError as e:
+        raise TypeError(
+            f"Value must be any string, instead got type {type(value)}"
+        ) from e.__cause__
 
-    if not is_address(hex_address):
+    # if `hex_address` is not a valid address
+    if hex_address_fullmatch(hex_address) is None:
         raise ValueError(
             f"Unknown format {repr(value)}, attempted to normalize to {repr(hex_address)}"
         )
@@ -86,33 +99,7 @@ def to_normalized_address(value: Union[AnyAddress, str, bytes]) -> HexAddress:
     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
-
-
-BytesLike = Union[Primitives, bytearray, memoryview]
+encode_memoryview = compose(encode_hex, bytes)
 
 
 def to_hex(
@@ -132,13 +119,15 @@ def to_hex(
         return encode_hex(address_bytes)
 
     if isinstance(address_bytes, memoryview):
-        return encode_hex(bytes(address_bytes))
+        return encode_memoryview(address_bytes)
 
     raise TypeError(
         f"Unsupported type: '{repr(type(address_bytes))}'. Must be one of: bytes or bytearray."
     )
 
 
-# force _hasher_first_run and _preimage_first_run to execute so we can cache the new hasher
-keccak(b"")
-keccak = keccak.hasher
+del hexlify
+del Optional, Union
+del AnyAddress, ChecksumAddress, HexAddress, HexStr, Primitives
+del _HEX_ADDRESS_REGEXP, compose, keccak
+del BytesLike

cchecksum-0.0.9/cchecksum/checksum.pyi

@@ -0,0 +1,31 @@
+from typing import Union
+
+from eth_typing import AnyAddress, ChecksumAddress
+
+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.
+    """

{cchecksum-0.0.7 → cchecksum-0.0.9/cchecksum.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: cchecksum
-Version: 0.0.7
+Version: 0.0.9
 Summary: A ~2x faster drop-in replacement for eth_utils.to_checksum_address. Raises the exact same Exceptions. Implemented in C.
 Home-page: https://github.com/BobTheBuidler/cchecksum
 Author: BobTheBuidler
@@ -15,6 +15,7 @@ Dynamic: author
 Dynamic: author-email
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{cchecksum-0.0.7 → cchecksum-0.0.9}/cchecksum.egg-info/SOURCES.txt

@@ -11,10 +11,11 @@ test_checksum.py
 .github/workflows/pytest.yaml
 .github/workflows/release.yaml
 cchecksum/__init__.py
-cchecksum/_cchecksum.pyi
 cchecksum/_checksum.c
+cchecksum/_checksum.pyi
 cchecksum/_checksum.pyx
 cchecksum/checksum.py
+cchecksum/checksum.pyi
 cchecksum/py.typed
 cchecksum.egg-info/PKG-INFO
 cchecksum.egg-info/SOURCES.txt

cchecksum-0.0.7/cchecksum/_cchecksum.pyi

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