cchecksum 0.0.8__tar.gz → 0.0.10__tar.gz

{cchecksum-0.0.8 → cchecksum-0.0.10}/.github/workflows/deploy-docs.yaml

@@ -5,6 +5,9 @@ on:
     branches:
       - master
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
 # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
 permissions:
@@ -16,13 +19,12 @@ permissions:
 jobs:
   build-and-deploy:
     runs-on: ubuntu-latest
-    
-    environment:
-      name: github-pages
       
     steps:
       - name: Check out code
         uses: actions/checkout@v2
+        with:
+          persist-credentials: false
 
       - name: Set up Python
         uses: actions/setup-python@v2
@@ -55,6 +57,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           ref: gh-pages
+          persist-credentials: false
           
       - name: Setup Pages
         uses: actions/configure-pages@v4

{cchecksum-0.0.8/cchecksum.egg-info → cchecksum-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cchecksum
-Version: 0.0.8
+Version: 0.0.10
 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

{cchecksum-0.0.8 → cchecksum-0.0.10}/cchecksum/_checksum.c

@@ -2599,32 +2599,12 @@ static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_s
     return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
 }
 
-/* decode_c_bytes.proto */
-static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes(
-         const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop,
+/* decode_c_string.proto */
+static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
+         const char* cstring, Py_ssize_t start, Py_ssize_t stop,
          const char* encoding, const char* errors,
          PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors));
 
-/* decode_bytes.proto */
-static CYTHON_INLINE PyObject* __Pyx_decode_bytes(
-         PyObject* string, Py_ssize_t start, Py_ssize_t stop,
-         const char* encoding, const char* errors,
-         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
-    char* as_c_string;
-    Py_ssize_t size;
-#if CYTHON_ASSUME_SAFE_MACROS
-    as_c_string = PyBytes_AS_STRING(string);
-    size = PyBytes_GET_SIZE(string);
-#else
-    if (PyBytes_AsStringAndSize(string, &as_c_string, &size) < 0) {
-        return NULL;
-    }
-#endif
-    return __Pyx_decode_c_bytes(
-        as_c_string, size,
-        start, stop, encoding, errors, decode_func);
-}
-
 /* PyObject_GenericGetAttrNoDict.proto */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
@@ -2903,7 +2883,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 +3014,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 +3117,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 +3148,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 +3206,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 +3324,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 +3531,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 +3716,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 +3911,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 +17982,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 +17995,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 +18005,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 +18068,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 +18082,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 +18095,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 +18106,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 +18115,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 +18132,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 +18143,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 +18247,23 @@ 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')             # <<<<<<<<<<<<<<
+ *     return 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_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_1); __pyx_t_1 = 0;
-  __pyx_r = ((PyObject*)__pyx_t_2);
-  __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_decode_c_string(((char const *)__pyx_v_buffer), 0, 42, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __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 +18271,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 +19333,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 +19395,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 +19452,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 +19567,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 +20641,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 +20659,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)
@@ -23300,12 +23243,20 @@ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) {
     }
 }
 
-/* decode_c_bytes */
-static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes(
-         const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop,
+/* decode_c_string */
+static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
+         const char* cstring, Py_ssize_t start, Py_ssize_t stop,
          const char* encoding, const char* errors,
          PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
+    Py_ssize_t length;
     if (unlikely((start < 0) | (stop < 0))) {
+        size_t slen = strlen(cstring);
+        if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "c-string too long to convert to Python");
+            return NULL;
+        }
+        length = (Py_ssize_t) slen;
         if (start < 0) {
             start += length;
             if (start < 0)
@@ -23314,8 +23265,6 @@ static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes(
         if (stop < 0)
             stop += length;
     }
-    if (stop > length)
-        stop = length;
     if (unlikely(stop <= start))
         return __Pyx_NewRef(__pyx_empty_unicode);
     length = stop - start;
@@ -26271,7 +26220,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 +26231,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.10/cchecksum/_checksum.pyi

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

{cchecksum-0.0.8 → cchecksum-0.0.10}/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,18 +38,18 @@ 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
 
     # 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')
+    return buffer[:42].decode('ascii')

{cchecksum-0.0.8 → cchecksum-0.0.10}/cchecksum/checksum.py

@@ -52,8 +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_hex_no_0x = hash_address(norm_address_no_0x).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:

{cchecksum-0.0.8 → cchecksum-0.0.10/cchecksum.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cchecksum
-Version: 0.0.8
+Version: 0.0.10
 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

{cchecksum-0.0.8 → cchecksum-0.0.10}/docs/conf.py

@@ -36,6 +36,7 @@ exclude_patterns = [
 # Looks for objects in documentation of external libraries
 intersphinx_mapping = {
     "eth_typing": ("https://eth-typing.readthedocs.io/en/stable/", None),
+    "eth_utils": ("https://eth-utils.readthedocs.io/en/stable/", None),
     "python": ("https://docs.python.org/3", None),
 }
 

cchecksum-0.0.8/cchecksum/_checksum.pyi

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