diff --git a/include/valkey/sockcompat.h b/include/valkey/sockcompat.h
index 5298f152..84afeeab 100644
--- a/include/valkey/sockcompat.h
+++ b/include/valkey/sockcompat.h
@@ -28,8 +28,8 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef __SOCKCOMPAT_H
-#define __SOCKCOMPAT_H
+#ifndef VALKEY_SOCKCOMPAT_H
+#define VALKEY_SOCKCOMPAT_H
 
 #ifndef _WIN32
 /* For POSIX systems we use the standard BSD socket API. */
@@ -92,4 +92,4 @@ int win32_valkeyKeepAlive(SOCKET sockfd, int interval_ms);
 #endif /* VALKEY_SOCKCOMPAT_IMPLEMENTATION */
 #endif /* _WIN32 */
 
-#endif /* __SOCKCOMPAT_H */
+#endif /* VALKEY_SOCKCOMPAT_H */
diff --git a/include/valkey/valkeycluster.h b/include/valkey/valkeycluster.h
index 0eef6c03..fe5c2c1f 100644
--- a/include/valkey/valkeycluster.h
+++ b/include/valkey/valkeycluster.h
@@ -30,8 +30,8 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef __HIRCLUSTER_H
-#define __HIRCLUSTER_H
+#ifndef VALKEYCLUSTER_H
+#define VALKEYCLUSTER_H
 
 #include "async.h"
 #include "dict.h"
@@ -342,4 +342,4 @@ valkeyClusterNode *valkeyClusterGetNodeByKey(valkeyClusterContext *cc,
 }
 #endif
 
-#endif
+#endif /* VALKEYCLUSTER_H */
diff --git a/include/valkey/valkeycluster_ssl.h b/include/valkey/valkeycluster_ssl.h
index 86cec0b6..06e9f8f8 100644
--- a/include/valkey/valkeycluster_ssl.h
+++ b/include/valkey/valkeycluster_ssl.h
@@ -26,8 +26,8 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
-#ifndef __HIRCLUSTER_SSL_H
-#define __HIRCLUSTER_SSL_H
+#ifndef VALKEYCLUSTER_SSL_H
+#define VALKEYCLUSTER_SSL_H
 
 #include "valkeycluster.h"
 #include "valkey_ssl.h"
@@ -46,4 +46,4 @@ int valkeyClusterSetOptionEnableSSL(valkeyClusterContext *cc,
 }
 #endif
 
-#endif /* __HIRCLUSTER_SSL_H */
+#endif /* VALKEYCLUSTER_SSL_H */
diff --git a/src/adlist.h b/src/adlist.h
index 982894e4..18ee6008 100644
--- a/src/adlist.h
+++ b/src/adlist.h
@@ -28,8 +28,8 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef __ADLIST_H__
-#define __ADLIST_H__
+#ifndef VALKEY_ADLIST_H
+#define VALKEY_ADLIST_H
 
 /* Node, List, and Iterator are the only data structures used currently. */
 
@@ -91,4 +91,4 @@ void listRotate(hilist *list);
 #define AL_START_HEAD 0
 #define AL_START_TAIL 1
 
-#endif /* __ADLIST_H__ */
+#endif /* VALKEY_ADLIST_H */
diff --git a/src/command.h b/src/command.h
index bc62d017..911ebf13 100644
--- a/src/command.h
+++ b/src/command.h
@@ -29,8 +29,8 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef __COMMAND_H_
-#define __COMMAND_H_
+#ifndef VALKEY_COMMAND_H
+#define VALKEY_COMMAND_H
 
 #include <stdint.h>
 
@@ -84,4 +84,4 @@ void valkey_parse_cmd(struct cmd *r);
 struct cmd *command_get(void);
 void command_destroy(struct cmd *command);
 
-#endif
+#endif /* VALKEY_COMMAND_H */
diff --git a/src/valkeycluster.c b/src/valkeycluster.c
index 1ca0327e..b1cd5da1 100644
--- a/src/valkeycluster.c
+++ b/src/valkeycluster.c
@@ -195,8 +195,8 @@ static unsigned int keyHashSlot(char *key, int keylen) {
     return crc16(key + s + 1, e - s - 1) & 0x3FFF;
 }
 
-static void __valkeyClusterSetError(valkeyClusterContext *cc, int type,
-                                    const char *str) {
+static void valkeyClusterSetError(valkeyClusterContext *cc, int type,
+                                  const char *str) {
     size_t len;
 
     if (cc == NULL) {
@@ -365,13 +365,13 @@ static int authenticate(valkeyClusterContext *cc, valkeyContext *c) {
     }
 
     if (reply == NULL) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                "Command AUTH reply error (NULL)");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                              "Command AUTH reply error (NULL)");
         goto error;
     }
 
     if (reply->type == VALKEY_REPLY_ERROR) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER, reply->str);
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER, reply->str);
         goto error;
     }
 
@@ -398,23 +398,23 @@ static valkeyClusterNode *node_get_with_slots(valkeyClusterContext *cc,
     }
 
     if (host_elem->type != VALKEY_REPLY_STRING || host_elem->len <= 0) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                "Command(cluster slots) reply error: "
-                                "node ip is not string.");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                              "Command(cluster slots) reply error: "
+                              "node ip is not string.");
         goto error;
     }
 
     if (port_elem->type != VALKEY_REPLY_INTEGER || port_elem->integer <= 0) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                "Command(cluster slots) reply error: "
-                                "node port is not integer.");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                              "Command(cluster slots) reply error: "
+                              "node port is not integer.");
         goto error;
     }
 
     if (!vk_valid_port((int)port_elem->integer)) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                "Command(cluster slots) reply error: "
-                                "node port is not valid.");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                              "Command(cluster slots) reply error: "
+                              "node port is not valid.");
         goto error;
     }
 
@@ -451,7 +451,7 @@ static valkeyClusterNode *node_get_with_slots(valkeyClusterContext *cc,
     return node;
 
 oom:
-    __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+    valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
     // passthrough
 
 error:
@@ -506,7 +506,7 @@ static valkeyClusterNode *node_get_with_nodes(valkeyClusterContext *cc,
 
     /* Get the ip part */
     if ((p = strrchr(node->addr, IP_PORT_SEPARATOR)) == NULL) {
-        __valkeyClusterSetError(
+        valkeyClusterSetError(
             cc, VALKEY_ERR_OTHER,
             "server address is incorrect, port separator missing.");
         goto error;
@@ -523,7 +523,7 @@ static valkeyClusterNode *node_get_with_nodes(valkeyClusterContext *cc,
     return node;
 
 oom:
-    __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+    valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
     // passthrough
 
 error:
@@ -609,15 +609,14 @@ static int cluster_master_slave_mapping_with_name(valkeyClusterContext *cc,
     } else {
         node_old = dictGetEntryVal(di);
         if (node_old == NULL) {
-            __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                    "dict get value null");
+            valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "dict get value null");
             return VALKEY_ERR;
         }
 
         if (node->role == VALKEY_ROLE_MASTER &&
             node_old->role == VALKEY_ROLE_MASTER) {
-            __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                    "two masters have the same name");
+            valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                                  "two masters have the same name");
             return VALKEY_ERR;
         } else if (node->role == VALKEY_ROLE_MASTER &&
                    node_old->role == VALKEY_ROLE_SLAVE) {
@@ -669,7 +668,7 @@ static int cluster_master_slave_mapping_with_name(valkeyClusterContext *cc,
     return VALKEY_OK;
 
 oom:
-    __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+    valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
     return VALKEY_ERR;
 }
 
@@ -699,9 +698,9 @@ dict *parse_cluster_slots(valkeyClusterContext *cc, valkeyReply *reply,
     }
 
     if (reply->type != VALKEY_REPLY_ARRAY || reply->elements <= 0) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                "Command(cluster slots) reply error: "
-                                "reply is not an array.");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                              "Command(cluster slots) reply error: "
+                              "reply is not an array.");
         goto error;
     }
 
@@ -709,9 +708,9 @@ dict *parse_cluster_slots(valkeyClusterContext *cc, valkeyReply *reply,
         elem_slots = reply->element[i];
         if (elem_slots->type != VALKEY_REPLY_ARRAY ||
             elem_slots->elements < 3) {
-            __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                    "Command(cluster slots) reply error: "
-                                    "first sub_reply is not an array.");
+            valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                                  "Command(cluster slots) reply error: "
+                                  "first sub_reply is not an array.");
             goto error;
         }
 
@@ -725,27 +724,25 @@ dict *parse_cluster_slots(valkeyClusterContext *cc, valkeyReply *reply,
             if (idx == 0) {
                 elem_slots_begin = elem_slots->element[idx];
                 if (elem_slots_begin->type != VALKEY_REPLY_INTEGER) {
-                    __valkeyClusterSetError(
-                        cc, VALKEY_ERR_OTHER,
-                        "Command(cluster slots) reply error: "
-                        "slot begin is not an integer.");
+                    valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                                          "Command(cluster slots) reply error: "
+                                          "slot begin is not an integer.");
                     goto error;
                 }
                 slot->start = (int)(elem_slots_begin->integer);
             } else if (idx == 1) {
                 elem_slots_end = elem_slots->element[idx];
                 if (elem_slots_end->type != VALKEY_REPLY_INTEGER) {
-                    __valkeyClusterSetError(
-                        cc, VALKEY_ERR_OTHER,
-                        "Command(cluster slots) reply error: "
-                        "slot end is not an integer.");
+                    valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                                          "Command(cluster slots) reply error: "
+                                          "slot end is not an integer.");
                     goto error;
                 }
 
                 slot->end = (int)(elem_slots_end->integer);
 
                 if (slot->start > slot->end) {
-                    __valkeyClusterSetError(
+                    valkeyClusterSetError(
                         cc, VALKEY_ERR_OTHER,
                         "Command(cluster slots) reply error: "
                         "slot begin is bigger than slot end.");
@@ -755,7 +752,7 @@ dict *parse_cluster_slots(valkeyClusterContext *cc, valkeyReply *reply,
                 elem_nodes = elem_slots->element[idx];
                 if (elem_nodes->type != VALKEY_REPLY_ARRAY ||
                     elem_nodes->elements < 2) {
-                    __valkeyClusterSetError(
+                    valkeyClusterSetError(
                         cc, VALKEY_ERR_OTHER,
                         "Command(cluster slots) reply error: "
                         "nodes sub_reply is not an correct array.");
@@ -768,10 +765,9 @@ dict *parse_cluster_slots(valkeyClusterContext *cc, valkeyReply *reply,
                 if (elem_ip == NULL || elem_port == NULL ||
                     elem_ip->type != VALKEY_REPLY_STRING ||
                     elem_port->type != VALKEY_REPLY_INTEGER) {
-                    __valkeyClusterSetError(
-                        cc, VALKEY_ERR_OTHER,
-                        "Command(cluster slots) reply error: "
-                        "master ip or port is not correct.");
+                    valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                                          "Command(cluster slots) reply error: "
+                                          "master ip or port is not correct.");
                     goto error;
                 }
 
@@ -855,7 +851,7 @@ dict *parse_cluster_slots(valkeyClusterContext *cc, valkeyReply *reply,
     return nodes;
 
 oom:
-    __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+    valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
     // passthrough
 
 error:
@@ -908,8 +904,8 @@ dict *parse_cluster_nodes(valkeyClusterContext *cc, char *str, int str_len,
             }
 
             if (count_part < 8) {
-                __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                        "split cluster nodes error");
+                valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                                      "split cluster nodes error");
                 goto error;
             }
 
@@ -951,7 +947,7 @@ dict *parse_cluster_nodes(valkeyClusterContext *cc, char *str, int str_len,
                 ret = dictAdd(nodes, key, master);
                 if (ret != DICT_OK) {
                     // Key already exists, but possibly an OOM error
-                    __valkeyClusterSetError(
+                    valkeyClusterSetError(
                         cc, VALKEY_ERR_OTHER,
                         "The address already exists in the nodes");
                     sdsfree(key);
@@ -1038,7 +1034,7 @@ dict *parse_cluster_nodes(valkeyClusterContext *cc, char *str, int str_len,
     }
 
     if (slot_ranges_found == 0) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "No slot information");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "No slot information");
         goto error;
     }
 
@@ -1049,7 +1045,7 @@ dict *parse_cluster_nodes(valkeyClusterContext *cc, char *str, int str_len,
     return nodes;
 
 oom:
-    __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+    valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
     // passthrough
 
 error:
@@ -1074,7 +1070,7 @@ static int clusterUpdateRouteSendCommand(valkeyClusterContext *cc,
         const char *msg = (cc->flags & VALKEYCLUSTER_FLAG_ROUTE_USE_SLOTS ?
                                "Command (cluster slots) send error." :
                                "Command (cluster nodes) send error.");
-        __valkeyClusterSetError(cc, c->err, msg);
+        valkeyClusterSetError(cc, c->err, msg);
         return VALKEY_ERR;
     }
     /* Flush buffer to socket. */
@@ -1090,20 +1086,20 @@ static int handleClusterSlotsReply(valkeyClusterContext *cc, valkeyContext *c) {
     int result = valkeyGetReply(c, (void **)&reply);
     if (result != VALKEY_OK) {
         if (c->err == VALKEY_ERR_TIMEOUT) {
-            __valkeyClusterSetError(
+            valkeyClusterSetError(
                 cc, c->err,
                 "Command (cluster slots) reply error (socket timeout)");
         } else {
-            __valkeyClusterSetError(
+            valkeyClusterSetError(
                 cc, VALKEY_ERR_OTHER,
                 "Command (cluster slots) reply error (NULL).");
         }
         return VALKEY_ERR;
     } else if (reply->type != VALKEY_REPLY_ARRAY) {
         if (reply->type == VALKEY_REPLY_ERROR) {
-            __valkeyClusterSetError(cc, VALKEY_ERR_OTHER, reply->str);
+            valkeyClusterSetError(cc, VALKEY_ERR_OTHER, reply->str);
         } else {
-            __valkeyClusterSetError(
+            valkeyClusterSetError(
                 cc, VALKEY_ERR_OTHER,
                 "Command (cluster slots) reply error: type is not array.");
         }
@@ -1122,22 +1118,22 @@ static int handleClusterNodesReply(valkeyClusterContext *cc, valkeyContext *c) {
     int result = valkeyGetReply(c, (void **)&reply);
     if (result != VALKEY_OK) {
         if (c->err == VALKEY_ERR_TIMEOUT) {
-            __valkeyClusterSetError(cc, c->err,
-                                    "Command (cluster nodes) reply error "
-                                    "(socket timeout)");
+            valkeyClusterSetError(cc, c->err,
+                                  "Command (cluster nodes) reply error "
+                                  "(socket timeout)");
         } else {
-            __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                    "Command (cluster nodes) reply error "
-                                    "(NULL).");
+            valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                                  "Command (cluster nodes) reply error "
+                                  "(NULL).");
         }
         return VALKEY_ERR;
     } else if (reply->type != VALKEY_REPLY_STRING) {
         if (reply->type == VALKEY_REPLY_ERROR) {
-            __valkeyClusterSetError(cc, VALKEY_ERR_OTHER, reply->str);
+            valkeyClusterSetError(cc, VALKEY_ERR_OTHER, reply->str);
         } else {
-            __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                    "Command(cluster nodes) reply error: "
-                                    "type is not string.");
+            valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                                  "Command(cluster nodes) reply error: "
+                                  "type is not string.");
         }
         freeReplyObject(reply);
         return VALKEY_ERR;
@@ -1171,7 +1167,7 @@ static int cluster_update_route_by_addr(valkeyClusterContext *cc,
     }
 
     if (ip == NULL || port <= 0) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "Ip or port error!");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "Ip or port error!");
         goto error;
     }
 
@@ -1182,7 +1178,7 @@ static int cluster_update_route_by_addr(valkeyClusterContext *cc,
 
     c = valkeyConnectWithOptions(&options);
     if (c == NULL) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+        valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
         return VALKEY_ERR;
     }
 
@@ -1191,12 +1187,12 @@ static int cluster_update_route_by_addr(valkeyClusterContext *cc,
     }
 
     if (c->err) {
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         goto error;
     }
 
     if (cc->ssl && cc->ssl_init_fn(c, cc->ssl) != VALKEY_OK) {
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         goto error;
     }
 
@@ -1241,8 +1237,8 @@ static int updateNodesAndSlotmap(valkeyClusterContext *cc, dict *nodes) {
     while ((de = dictNext(&di))) {
         valkeyClusterNode *master = dictGetEntryVal(de);
         if (master->role != VALKEY_ROLE_MASTER) {
-            __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                    "Node role must be master");
+            valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                                  "Node role must be master");
             goto error;
         }
 
@@ -1257,14 +1253,14 @@ static int updateNodesAndSlotmap(valkeyClusterContext *cc, dict *nodes) {
         while ((ln = listNext(&li))) {
             cluster_slot *slot = listNodeValue(ln);
             if (slot->start > slot->end || slot->end >= VALKEYCLUSTER_SLOTS) {
-                __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                        "Slot region for node is invalid");
+                valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                                      "Slot region for node is invalid");
                 goto error;
             }
             for (uint32_t i = slot->start; i <= slot->end; i++) {
                 if (table[i] != NULL) {
-                    __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                            "Different node holds same slot");
+                    valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                                          "Different node holds same slot");
                     goto error;
                 }
                 table[i] = master;
@@ -1305,7 +1301,7 @@ static int updateNodesAndSlotmap(valkeyClusterContext *cc, dict *nodes) {
     return VALKEY_OK;
 
 oom:
-    __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+    valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
     // passthrough
 error:
     vk_free(table);
@@ -1324,7 +1320,7 @@ int valkeyClusterUpdateSlotmap(valkeyClusterContext *cc) {
     }
 
     if (cc->nodes == NULL) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "no server address");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "no server address");
         return VALKEY_ERR;
     }
 
@@ -1350,8 +1346,7 @@ int valkeyClusterUpdateSlotmap(valkeyClusterContext *cc) {
     }
 
     if (flag_err_not_set) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                "no valid server address");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "no valid server address");
     }
 
     return VALKEY_ERR;
@@ -1420,35 +1415,12 @@ void valkeyClusterFree(valkeyClusterContext *cc) {
     vk_free(cc);
 }
 
-/* Connect to a Valkey cluster. On error the field error in the returned
- * context will be set to the return value of the error function.
- * When no set of reply functions is given, the default set will be used. */
-static int _valkeyClusterConnect2(valkeyClusterContext *cc) {
-
-    if (cc->nodes == NULL || dictSize(cc->nodes) == 0) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                "servers address does not set up");
-        return VALKEY_ERR;
-    }
-
-    return valkeyClusterUpdateSlotmap(cc);
-}
-
-/* Connect to a Valkey cluster. On error the field error in the returned
- * context will be set to the return value of the error function.
- * When no set of reply functions is given, the default set will be used. */
-static valkeyClusterContext *_valkeyClusterConnect(valkeyClusterContext *cc,
-                                                   const char *addrs) {
-
-    int ret;
-
-    ret = valkeyClusterSetOptionAddNodes(cc, addrs);
-    if (ret != VALKEY_OK) {
+static valkeyClusterContext *
+valkeyClusterConnectInternal(valkeyClusterContext *cc, const char *addrs) {
+    if (valkeyClusterSetOptionAddNodes(cc, addrs) != VALKEY_OK) {
         return cc;
     }
-
     valkeyClusterUpdateSlotmap(cc);
-
     return cc;
 }
 
@@ -1463,7 +1435,7 @@ valkeyClusterContext *valkeyClusterConnect(const char *addrs, int flags) {
 
     cc->flags = flags;
 
-    return _valkeyClusterConnect(cc, addrs);
+    return valkeyClusterConnectInternal(cc, addrs);
 }
 
 valkeyClusterContext *valkeyClusterConnectWithTimeout(const char *addrs,
@@ -1488,7 +1460,7 @@ valkeyClusterContext *valkeyClusterConnectWithTimeout(const char *addrs,
 
     memcpy(cc->connect_timeout, &tv, sizeof(struct timeval));
 
-    return _valkeyClusterConnect(cc, addrs);
+    return valkeyClusterConnectInternal(cc, addrs);
 }
 
 int valkeyClusterSetOptionAddNode(valkeyClusterContext *cc, const char *addr) {
@@ -1518,7 +1490,7 @@ int valkeyClusterSetOptionAddNode(valkeyClusterContext *cc, const char *addr) {
 
         char *p;
         if ((p = strrchr(addr, IP_PORT_SEPARATOR)) == NULL) {
-            __valkeyClusterSetError(
+            valkeyClusterSetError(
                 cc, VALKEY_ERR_OTHER,
                 "server address is incorrect, port separator missing.");
             return VALKEY_ERR;
@@ -1526,7 +1498,7 @@ int valkeyClusterSetOptionAddNode(valkeyClusterContext *cc, const char *addr) {
         // p includes separator
 
         if (p - addr <= 0) { /* length until separator */
-            __valkeyClusterSetError(
+            valkeyClusterSetError(
                 cc, VALKEY_ERR_OTHER,
                 "server address is incorrect, address part missing.");
             return VALKEY_ERR;
@@ -1539,7 +1511,7 @@ int valkeyClusterSetOptionAddNode(valkeyClusterContext *cc, const char *addr) {
         p++; // remove separator character
 
         if (strlen(p) <= 0) {
-            __valkeyClusterSetError(
+            valkeyClusterSetError(
                 cc, VALKEY_ERR_OTHER,
                 "server address is incorrect, port part missing.");
             goto error;
@@ -1547,8 +1519,8 @@ int valkeyClusterSetOptionAddNode(valkeyClusterContext *cc, const char *addr) {
 
         port = vk_atoi(p, strlen(p));
         if (port <= 0) {
-            __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                    "server port is incorrect");
+            valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                                  "server port is incorrect");
             goto error;
         }
 
@@ -1579,7 +1551,7 @@ int valkeyClusterSetOptionAddNode(valkeyClusterContext *cc, const char *addr) {
     return VALKEY_OK;
 
 oom:
-    __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+    valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
     // passthrough
 
 error:
@@ -1605,14 +1577,14 @@ int valkeyClusterSetOptionAddNodes(valkeyClusterContext *cc,
     address = sdssplitlen(addrs, strlen(addrs), CLUSTER_ADDRESS_SEPARATOR,
                           strlen(CLUSTER_ADDRESS_SEPARATOR), &address_count);
     if (address == NULL) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+        valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
         return VALKEY_ERR;
     }
 
     if (address_count <= 0) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                "invalid server addresses (example format: "
-                                "127.0.0.1:1234,127.0.0.2:5678)");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                              "invalid server addresses (example format: "
+                              "127.0.0.1:1234,127.0.0.2:5678)");
         sdsfreesplitres(address, address_count);
         return VALKEY_ERR;
     }
@@ -1733,7 +1705,7 @@ int valkeyClusterSetOptionConnectTimeout(valkeyClusterContext *cc,
     if (cc->connect_timeout == NULL) {
         cc->connect_timeout = vk_malloc(sizeof(struct timeval));
         if (cc->connect_timeout == NULL) {
-            __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+            valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
             return VALKEY_ERR;
         }
     }
@@ -1756,7 +1728,7 @@ int valkeyClusterSetOptionTimeout(valkeyClusterContext *cc,
         if (cc->command_timeout == NULL) {
             cc->command_timeout = vk_malloc(sizeof(struct timeval));
             if (cc->command_timeout == NULL) {
-                __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+                valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
                 return VALKEY_ERR;
             }
         }
@@ -1821,7 +1793,12 @@ int valkeyClusterConnect2(valkeyClusterContext *cc) {
         return VALKEY_ERR;
     }
 
-    return _valkeyClusterConnect2(cc);
+    if (cc->nodes == NULL || dictSize(cc->nodes) == 0) {
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                              "server address not configured");
+        return VALKEY_ERR;
+    }
+    return valkeyClusterUpdateSlotmap(cc);
 }
 
 valkeyContext *ctx_get_by_node(valkeyClusterContext *cc,
@@ -1841,7 +1818,7 @@ valkeyContext *ctx_get_by_node(valkeyClusterContext *cc,
             }
 
             if (cc->ssl && cc->ssl_init_fn(c, cc->ssl) != VALKEY_OK) {
-                __valkeyClusterSetError(cc, c->err, c->errstr);
+                valkeyClusterSetError(cc, c->err, c->errstr);
             }
 
             authenticate(cc, c); // err and errstr handled in function
@@ -1861,7 +1838,7 @@ valkeyContext *ctx_get_by_node(valkeyClusterContext *cc,
 
     c = valkeyConnectWithOptions(&options);
     if (c == NULL) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+        valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
         return NULL;
     }
 
@@ -1870,13 +1847,13 @@ valkeyContext *ctx_get_by_node(valkeyClusterContext *cc,
     }
 
     if (c->err) {
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         valkeyFree(c);
         return NULL;
     }
 
     if (cc->ssl && cc->ssl_init_fn(c, cc->ssl) != VALKEY_OK) {
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         valkeyFree(c);
         return NULL;
     }
@@ -1898,18 +1875,18 @@ static valkeyClusterNode *node_get_by_table(valkeyClusterContext *cc,
     }
 
     if (slot_num >= VALKEYCLUSTER_SLOTS) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "invalid slot");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "invalid slot");
         return NULL;
     }
 
     if (cc->table == NULL) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "slotmap not available");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "slotmap not available");
         return NULL;
     }
 
     if (cc->table[slot_num] == NULL) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                "slot not served by any node");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                              "slot not served by any node");
         return NULL;
     }
 
@@ -1922,8 +1899,8 @@ static valkeyClusterNode *node_get_by_table(valkeyClusterContext *cc,
  * is used, you need to call valkeyGetReply yourself to retrieve
  * the reply (or replies in pub/sub).
  */
-static int __valkeyClusterAppendCommand(valkeyClusterContext *cc,
-                                        struct cmd *command) {
+static int valkeyClusterAppendCommandInternal(valkeyClusterContext *cc,
+                                              struct cmd *command) {
 
     valkeyClusterNode *node;
     valkeyContext *c = NULL;
@@ -1941,13 +1918,13 @@ static int __valkeyClusterAppendCommand(valkeyClusterContext *cc,
     if (c == NULL) {
         return VALKEY_ERR;
     } else if (c->err) {
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         return VALKEY_ERR;
     }
 
     if (valkeyAppendFormattedCommand(c, command->cmd, command->clen) !=
         VALKEY_OK) {
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         return VALKEY_ERR;
     }
 
@@ -1956,9 +1933,9 @@ static int __valkeyClusterAppendCommand(valkeyClusterContext *cc,
 
 /* Helper functions for the valkeyClusterGetReply* family of functions.
  */
-static int __valkeyClusterGetReplyFromNode(valkeyClusterContext *cc,
-                                           valkeyClusterNode *node,
-                                           void **reply) {
+static int valkeyClusterGetReplyFromNode(valkeyClusterContext *cc,
+                                         valkeyClusterNode *node,
+                                         void **reply) {
     valkeyContext *c;
 
     if (cc == NULL || node == NULL || reply == NULL)
@@ -1975,12 +1952,12 @@ static int __valkeyClusterGetReplyFromNode(valkeyClusterContext *cc,
                 cc->retry_count = 0;
             }
         }
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         return VALKEY_ERR;
     }
 
     if (valkeyGetReply(c, reply) != VALKEY_OK) {
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         return VALKEY_ERR;
     }
 
@@ -1990,21 +1967,6 @@ static int __valkeyClusterGetReplyFromNode(valkeyClusterContext *cc,
     return VALKEY_OK;
 }
 
-static int __valkeyClusterGetReply(valkeyClusterContext *cc, int slot_num,
-                                   void **reply) {
-    valkeyClusterNode *node;
-
-    if (cc == NULL || slot_num < 0 || reply == NULL)
-        return VALKEY_ERR;
-
-    node = node_get_by_table(cc, (uint32_t)slot_num);
-    if (node == NULL) {
-        return VALKEY_ERR;
-    }
-
-    return __valkeyClusterGetReplyFromNode(cc, node, reply);
-}
-
 /* Parses a MOVED or ASK error reply and returns the destination node. The slot
  * is returned by pointer, if provided. */
 static valkeyClusterNode *getNodeFromRedirectReply(valkeyClusterContext *cc,
@@ -2021,8 +1983,7 @@ static valkeyClusterNode *getNodeFromRedirectReply(valkeyClusterContext *cc,
         goto oom;
     }
     if (part_len != 3) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                "failed to parse redirect");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "failed to parse redirect");
         goto done;
     }
 
@@ -2034,16 +1995,16 @@ static valkeyClusterNode *getNodeFromRedirectReply(valkeyClusterContext *cc,
     /* Find the last occurance of the port separator since
      * IPv6 addresses can contain ':' */
     if ((p = strrchr(part[2], IP_PORT_SEPARATOR)) == NULL) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                "port separator missing in redirect");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                              "port separator missing in redirect");
         goto done;
     }
     // p includes separator
 
     /* Empty endpoint not supported yet */
     if (p - part[2] == 0) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                "endpoint missing in redirect");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                              "endpoint missing in redirect");
         goto done;
     }
 
@@ -2084,7 +2045,7 @@ static valkeyClusterNode *getNodeFromRedirectReply(valkeyClusterContext *cc,
     return node;
 
 oom:
-    __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+    valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
     sdsfreesplitres(part, part_len);
     if (node != NULL) {
         sdsfree(node->addr);
@@ -2134,7 +2095,7 @@ static void *valkey_cluster_command_execute(valkeyClusterContext *cc,
         if (c == NULL) {
             goto error;
         } else if (c->err) {
-            __valkeyClusterSetError(cc, c->err, c->errstr);
+            valkeyClusterSetError(cc, c->err, c->errstr);
             goto error;
         }
     }
@@ -2144,7 +2105,7 @@ static void *valkey_cluster_command_execute(valkeyClusterContext *cc,
 
     if (valkeyAppendFormattedCommand(c, command->cmd, command->clen) !=
         VALKEY_OK) {
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         goto error;
     }
 
@@ -2156,7 +2117,7 @@ static void *valkey_cluster_command_execute(valkeyClusterContext *cc,
     }
 
     if (valkeyGetReply(c, &reply) != VALKEY_OK) {
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         /* We may need to update the slotmap if this node is removed from the
          * cluster, but the current request may have already timed out so we
          * schedule it for later. */
@@ -2169,8 +2130,8 @@ static void *valkey_cluster_command_execute(valkeyClusterContext *cc,
     if (error_type > CLUSTER_NOT_ERR && error_type < CLUSTER_ERR_SENTINEL) {
         cc->retry_count++;
         if (cc->retry_count > cc->max_retry_count) {
-            __valkeyClusterSetError(cc, VALKEY_ERR_CLUSTER_TOO_MANY_RETRIES,
-                                    "too many cluster retries");
+            valkeyClusterSetError(cc, VALKEY_ERR_CLUSTER_TOO_MANY_RETRIES,
+                                  "too many cluster retries");
             goto error;
         }
 
@@ -2210,7 +2171,7 @@ static void *valkey_cluster_command_execute(valkeyClusterContext *cc,
             if (c == NULL) {
                 goto error;
             } else if (c->err) {
-                __valkeyClusterSetError(cc, c->err, c->errstr);
+                valkeyClusterSetError(cc, c->err, c->errstr);
                 goto error;
             }
 
@@ -2230,13 +2191,13 @@ static void *valkey_cluster_command_execute(valkeyClusterContext *cc,
             if (c == NULL) {
                 goto error;
             } else if (c->err) {
-                __valkeyClusterSetError(cc, c->err, c->errstr);
+                valkeyClusterSetError(cc, c->err, c->errstr);
                 goto error;
             }
 
             reply = valkeyCommand(c, VALKEY_COMMAND_ASKING);
             if (reply == NULL) {
-                __valkeyClusterSetError(cc, c->err, c->errstr);
+                valkeyClusterSetError(cc, c->err, c->errstr);
                 goto error;
             }
 
@@ -2294,15 +2255,15 @@ static int prepareCommand(valkeyClusterContext *cc, struct cmd *command) {
 
     valkey_parse_cmd(command);
     if (command->result == CMD_PARSE_ENOMEM) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+        valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
         return VALKEY_ERR;
     }
     if (command->result != CMD_PARSE_OK) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_PROTOCOL, command->errstr);
+        valkeyClusterSetError(cc, VALKEY_ERR_PROTOCOL, command->errstr);
         return VALKEY_ERR;
     }
     if (command->key.len == 0) {
-        __valkeyClusterSetError(
+        valkeyClusterSetError(
             cc, VALKEY_ERR_OTHER,
             "No keys in command(must have keys for valkey cluster mode)");
         return VALKEY_ERR;
@@ -2375,7 +2336,7 @@ void *valkeyClusterFormattedCommand(valkeyClusterContext *cc, char *cmd,
     return reply;
 
 oom:
-    __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+    valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
     // passthrough
 
 error:
@@ -2400,10 +2361,10 @@ void *valkeyClustervCommand(valkeyClusterContext *cc, const char *format,
     len = valkeyvFormatCommand(&cmd, format, ap);
 
     if (len == -1) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+        valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
         return NULL;
     } else if (len == -2) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "Invalid format string");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "Invalid format string");
         return NULL;
     }
 
@@ -2438,7 +2399,7 @@ void *valkeyClusterCommandToNode(valkeyClusterContext *cc,
     if (c == NULL) {
         return NULL;
     } else if (c->err) {
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         return NULL;
     }
 
@@ -2452,7 +2413,7 @@ void *valkeyClusterCommandToNode(valkeyClusterContext *cc,
     va_end(ap);
 
     if (ret != VALKEY_OK) {
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         return NULL;
     }
 
@@ -2464,7 +2425,7 @@ void *valkeyClusterCommandToNode(valkeyClusterContext *cc,
     }
 
     if (valkeyGetReply(c, &reply) != VALKEY_OK) {
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         if (c->err != VALKEY_ERR_OOM)
             cc->need_update_route = 1;
         return NULL;
@@ -2490,7 +2451,7 @@ void *valkeyClusterCommandArgv(valkeyClusterContext *cc, int argc,
 
     len = valkeyFormatCommandArgv(&cmd, argc, argv, argvlen);
     if (len == -1) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+        valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
         return NULL;
     }
 
@@ -2524,7 +2485,7 @@ int valkeyClusterAppendFormattedCommand(valkeyClusterContext *cc, char *cmd,
         goto error;
     }
 
-    if (__valkeyClusterAppendCommand(cc, command) != VALKEY_OK) {
+    if (valkeyClusterAppendCommandInternal(cc, command) != VALKEY_OK) {
         goto error;
     }
 
@@ -2536,7 +2497,7 @@ int valkeyClusterAppendFormattedCommand(valkeyClusterContext *cc, char *cmd,
     return VALKEY_OK;
 
 oom:
-    __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+    valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
     // passthrough
 
 error:
@@ -2555,10 +2516,10 @@ int valkeyClustervAppendCommand(valkeyClusterContext *cc, const char *format,
 
     len = valkeyvFormatCommand(&cmd, format, ap);
     if (len == -1) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+        valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
         return VALKEY_ERR;
     } else if (len == -2) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "Invalid format string");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "Invalid format string");
         return VALKEY_ERR;
     }
 
@@ -2607,7 +2568,7 @@ int valkeyClusterAppendCommandToNode(valkeyClusterContext *cc,
     if (c == NULL) {
         return VALKEY_ERR;
     } else if (c->err) {
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         return VALKEY_ERR;
     }
 
@@ -2619,13 +2580,13 @@ int valkeyClusterAppendCommandToNode(valkeyClusterContext *cc,
     if (len == -1) {
         goto oom;
     } else if (len == -2) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "Invalid format string");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "Invalid format string");
         return VALKEY_ERR;
     }
 
     // Append the command to the outgoing valkey buffer
     if (valkeyAppendFormattedCommand(c, cmd, len) != VALKEY_OK) {
-        __valkeyClusterSetError(cc, c->err, c->errstr);
+        valkeyClusterSetError(cc, c->err, c->errstr);
         vk_free(cmd);
         return VALKEY_ERR;
     }
@@ -2649,7 +2610,7 @@ int valkeyClusterAppendCommandToNode(valkeyClusterContext *cc,
 
 oom:
     command_destroy(command);
-    __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+    valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
     return VALKEY_ERR;
 }
 
@@ -2661,7 +2622,7 @@ int valkeyClusterAppendCommandArgv(valkeyClusterContext *cc, int argc,
 
     len = valkeyFormatCommandArgv(&cmd, argc, argv, argvlen);
     if (len == -1) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
+        valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
         return VALKEY_ERR;
     }
 
@@ -2774,35 +2735,35 @@ int valkeyClusterGetReply(valkeyClusterContext *cc, void **reply) {
 
     command = list_command->value;
     if (command == NULL) {
-        __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                "command in the requests list is null");
+        valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                              "command in the requests list is null");
         goto error;
     }
 
     /* Get reply when the command was sent via slot */
     slot_num = command->slot_num;
     if (slot_num >= 0) {
+        valkeyClusterNode *node;
+        if ((node = node_get_by_table(cc, (uint32_t)slot_num)) == NULL)
+            goto error;
+
         listDelNode(cc->requests, list_command);
-        return __valkeyClusterGetReply(cc, slot_num, reply);
+        return valkeyClusterGetReplyFromNode(cc, node, reply);
     }
     /* Get reply when the command was sent to a given node */
     if (command->node_addr != NULL) {
-        dictEntry *de;
-
-        de = dictFind(cc->nodes, command->node_addr);
-        if (de != NULL) {
-            listDelNode(cc->requests, list_command);
-            return __valkeyClusterGetReplyFromNode(cc, dictGetEntryVal(de),
-                                                   reply);
-        } else {
-            __valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
-                                    "command was sent to a now unknown node");
+        dictEntry *de = dictFind(cc->nodes, command->node_addr);
+        if (de == NULL) {
+            valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                                  "command was sent to a now unknown node");
             goto error;
         }
+
+        listDelNode(cc->requests, list_command);
+        return valkeyClusterGetReplyFromNode(cc, dictGetEntryVal(de), reply);
     }
 
 error:
-
     listDelNode(cc->requests, list_command);
     return VALKEY_ERR;
 }
@@ -2854,8 +2815,8 @@ void valkeyClusterReset(valkeyClusterContext *cc) {
 
 /*############valkey cluster async############*/
 
-static void __valkeyClusterAsyncSetError(valkeyClusterAsyncContext *acc,
-                                         int type, const char *str) {
+static void valkeyClusterAsyncSetError(valkeyClusterAsyncContext *acc, int type,
+                                       const char *str) {
 
     size_t len;
 
@@ -2938,7 +2899,7 @@ valkeyAsyncContext *actx_get_by_node(valkeyClusterAsyncContext *acc,
              * the cluster node object. Return an error until done.
              * An example scenario is when sending a command from a command
              * callback, which has a NULL reply due to a disconnect. */
-            __valkeyClusterAsyncSetError(acc, ac->c.err, ac->c.errstr);
+            valkeyClusterAsyncSetError(acc, ac->c.err, ac->c.errstr);
             return NULL;
         }
     }
@@ -2946,8 +2907,8 @@ valkeyAsyncContext *actx_get_by_node(valkeyClusterAsyncContext *acc,
     // No async context exists, perform a connect
 
     if (node->host == NULL || node->port <= 0) {
-        __valkeyClusterAsyncSetError(acc, VALKEY_ERR_OTHER,
-                                     "node host or port is error");
+        valkeyClusterAsyncSetError(acc, VALKEY_ERR_OTHER,
+                                   "node host or port is error");
         return NULL;
     }
 
@@ -2960,19 +2921,19 @@ valkeyAsyncContext *actx_get_by_node(valkeyClusterAsyncContext *acc,
 
     ac = valkeyAsyncConnectWithOptions(&options);
     if (ac == NULL) {
-        __valkeyClusterAsyncSetError(acc, VALKEY_ERR_OOM, "Out of memory");
+        valkeyClusterAsyncSetError(acc, VALKEY_ERR_OOM, "Out of memory");
         return NULL;
     }
 
     if (ac->err) {
-        __valkeyClusterAsyncSetError(acc, ac->err, ac->errstr);
+        valkeyClusterAsyncSetError(acc, ac->err, ac->errstr);
         valkeyAsyncFree(ac);
         return NULL;
     }
 
     if (acc->cc->ssl &&
         acc->cc->ssl_init_fn(&ac->c, acc->cc->ssl) != VALKEY_OK) {
-        __valkeyClusterAsyncSetError(acc, ac->c.err, ac->c.errstr);
+        valkeyClusterAsyncSetError(acc, ac->c.err, ac->c.errstr);
         valkeyAsyncFree(ac);
         return NULL;
     }
@@ -2988,7 +2949,7 @@ valkeyAsyncContext *actx_get_by_node(valkeyClusterAsyncContext *acc,
         }
 
         if (ret != VALKEY_OK) {
-            __valkeyClusterAsyncSetError(acc, ac->c.err, ac->c.errstr);
+            valkeyClusterAsyncSetError(acc, ac->c.err, ac->c.errstr);
             valkeyAsyncFree(ac);
             return NULL;
         }
@@ -2997,8 +2958,8 @@ valkeyAsyncContext *actx_get_by_node(valkeyClusterAsyncContext *acc,
     if (acc->adapter) {
         ret = acc->attach_fn(ac, acc->adapter);
         if (ret != VALKEY_OK) {
-            __valkeyClusterAsyncSetError(acc, VALKEY_ERR_OTHER,
-                                         "Failed to attach event adapter");
+            valkeyClusterAsyncSetError(acc, VALKEY_ERR_OTHER,
+                                       "Failed to attach event adapter");
             valkeyAsyncFree(ac);
             return NULL;
         }
@@ -3193,8 +3154,7 @@ static int updateSlotMapAsync(valkeyClusterAsyncContext *acc,
 
     if (ac == NULL) {
         if (acc->cc->nodes == NULL) {
-            __valkeyClusterAsyncSetError(acc, VALKEY_ERR_OTHER,
-                                         "no nodes added");
+            valkeyClusterAsyncSetError(acc, VALKEY_ERR_OTHER, "no nodes added");
             goto error;
         }
 
@@ -3272,7 +3232,7 @@ static void valkeyClusterAsyncCallback(valkeyAsyncContext *ac, void *r,
 
     if (reply == NULL) {
         /* Copy reply specific error from libvalkey */
-        __valkeyClusterAsyncSetError(acc, ac->err, ac->errstr);
+        valkeyClusterAsyncSetError(acc, ac->err, ac->errstr);
 
         node = (valkeyClusterNode *)ac->data;
         if (node == NULL)
@@ -3292,9 +3252,8 @@ static void valkeyClusterAsyncCallback(valkeyAsyncContext *ac, void *r,
         cad->retry_count++;
         if (cad->retry_count > cc->max_retry_count) {
             cad->retry_count = 0;
-            __valkeyClusterAsyncSetError(acc,
-                                         VALKEY_ERR_CLUSTER_TOO_MANY_RETRIES,
-                                         "too many cluster retries");
+            valkeyClusterAsyncSetError(acc, VALKEY_ERR_CLUSTER_TOO_MANY_RETRIES,
+                                       "too many cluster retries");
             goto done;
         }
 
@@ -3306,7 +3265,7 @@ static void valkeyClusterAsyncCallback(valkeyAsyncContext *ac, void *r,
 
             node = getNodeFromRedirectReply(cc, reply, &slot);
             if (node == NULL) {
-                __valkeyClusterAsyncSetError(acc, cc->err, cc->errstr);
+                valkeyClusterAsyncSetError(acc, cc->err, cc->errstr);
                 goto done;
             }
             /* Update the slot mapping entry for this slot. */
@@ -3319,7 +3278,7 @@ static void valkeyClusterAsyncCallback(valkeyAsyncContext *ac, void *r,
         case CLUSTER_ERR_ASK:
             node = getNodeFromRedirectReply(cc, reply, NULL);
             if (node == NULL) {
-                __valkeyClusterAsyncSetError(acc, cc->err, cc->errstr);
+                valkeyClusterAsyncSetError(acc, cc->err, cc->errstr);
                 goto done;
             }
 
@@ -3427,7 +3386,7 @@ int valkeyClusterAsyncFormattedCommand(valkeyClusterAsyncContext *acc,
     command->clen = len;
 
     if (prepareCommand(cc, command) != VALKEY_OK) {
-        __valkeyClusterAsyncSetError(acc, cc->err, cc->errstr);
+        valkeyClusterAsyncSetError(acc, cc->err, cc->errstr);
         goto error;
     }
 
@@ -3437,7 +3396,7 @@ int valkeyClusterAsyncFormattedCommand(valkeyClusterAsyncContext *acc,
         throttledUpdateSlotMapAsync(acc, NULL);
 
         /* node_get_by_table() has set the error on cc. */
-        __valkeyClusterAsyncSetError(acc, cc->err, cc->errstr);
+        valkeyClusterAsyncSetError(acc, cc->err, cc->errstr);
         goto error;
     }
 
@@ -3465,7 +3424,7 @@ int valkeyClusterAsyncFormattedCommand(valkeyClusterAsyncContext *acc,
     return VALKEY_OK;
 
 oom:
-    __valkeyClusterAsyncSetError(acc, VALKEY_ERR_OOM, "Out of memory");
+    valkeyClusterAsyncSetError(acc, VALKEY_ERR_OOM, "Out of memory");
     // passthrough
 
 error:
@@ -3532,7 +3491,7 @@ int valkeyClusterAsyncFormattedCommandToNode(valkeyClusterAsyncContext *acc,
     return VALKEY_OK;
 
 oom:
-    __valkeyClusterAsyncSetError(acc, VALKEY_ERR_OTHER, "Out of memory");
+    valkeyClusterAsyncSetError(acc, VALKEY_ERR_OTHER, "Out of memory");
     // passthrough
 
 error:
@@ -3553,11 +3512,11 @@ int valkeyClustervAsyncCommand(valkeyClusterAsyncContext *acc,
 
     len = valkeyvFormatCommand(&cmd, format, ap);
     if (len == -1) {
-        __valkeyClusterAsyncSetError(acc, VALKEY_ERR_OOM, "Out of memory");
+        valkeyClusterAsyncSetError(acc, VALKEY_ERR_OOM, "Out of memory");
         return VALKEY_ERR;
     } else if (len == -2) {
-        __valkeyClusterAsyncSetError(acc, VALKEY_ERR_OTHER,
-                                     "Invalid format string");
+        valkeyClusterAsyncSetError(acc, VALKEY_ERR_OTHER,
+                                   "Invalid format string");
         return VALKEY_ERR;
     }
 
@@ -3596,11 +3555,11 @@ int valkeyClusterAsyncCommandToNode(valkeyClusterAsyncContext *acc,
     va_end(ap);
 
     if (len == -1) {
-        __valkeyClusterAsyncSetError(acc, VALKEY_ERR_OTHER, "Out of memory");
+        valkeyClusterAsyncSetError(acc, VALKEY_ERR_OTHER, "Out of memory");
         return VALKEY_ERR;
     } else if (len == -2) {
-        __valkeyClusterAsyncSetError(acc, VALKEY_ERR_OTHER,
-                                     "Invalid format string");
+        valkeyClusterAsyncSetError(acc, VALKEY_ERR_OTHER,
+                                   "Invalid format string");
         return VALKEY_ERR;
     }
 
@@ -3620,7 +3579,7 @@ int valkeyClusterAsyncCommandArgv(valkeyClusterAsyncContext *acc,
 
     len = valkeyFormatCommandArgv(&cmd, argc, argv, argvlen);
     if (len == -1) {
-        __valkeyClusterAsyncSetError(acc, VALKEY_ERR_OOM, "Out of memory");
+        valkeyClusterAsyncSetError(acc, VALKEY_ERR_OOM, "Out of memory");
         return VALKEY_ERR;
     }
 
@@ -3644,7 +3603,7 @@ int valkeyClusterAsyncCommandArgvToNode(valkeyClusterAsyncContext *acc,
 
     len = valkeyFormatCommandArgv(&cmd, argc, argv, argvlen);
     if (len == -1) {
-        __valkeyClusterAsyncSetError(acc, VALKEY_ERR_OOM, "Out of memory");
+        valkeyClusterAsyncSetError(acc, VALKEY_ERR_OOM, "Out of memory");
         return VALKEY_ERR;
     }
 
diff --git a/src/vkutil.h b/src/vkutil.h
index 2d289946..f18f0499 100644
--- a/src/vkutil.h
+++ b/src/vkutil.h
@@ -30,8 +30,8 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef __VKUTIL_H_
-#define __VKUTIL_H_
+#ifndef VALKEY_VKUTIL_H
+#define VALKEY_VKUTIL_H
 
 #include <stdint.h>
 #include <sys/types.h>
@@ -175,4 +175,4 @@ int64_t vk_msec_now(void);
 
 uint16_t crc16(const char *buf, int len);
 
-#endif
+#endif /* VALKEY_VKUTIL_H */
diff --git a/src/win32.h b/src/win32.h
index c9ddd1ff..bd649334 100644
--- a/src/win32.h
+++ b/src/win32.h
@@ -28,8 +28,8 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
-#ifndef _WIN32_HELPER_INCLUDE
-#define _WIN32_HELPER_INCLUDE
+#ifndef VALKEY_WIN32_H
+#define VALKEY_WIN32_H
 #ifdef _MSC_VER
 
 #include <winsock2.h> /* for struct timeval */
@@ -100,4 +100,4 @@ __inline int c99_snprintf(char* str, size_t size, const char* format, ...)
 
 #endif /* _WIN32 */
 
-#endif /* _WIN32_HELPER_INCLUDE */
+#endif /* VALKEY_WIN32_H */
diff --git a/tests/test_utils.h b/tests/test_utils.h
index 85dba3ae..f92b882f 100644
--- a/tests/test_utils.h
+++ b/tests/test_utils.h
@@ -1,5 +1,5 @@
-#ifndef __TEST_UTILS_H__
-#define __TEST_UTILS_H__
+#ifndef VALKEY_TEST_UTILS_H
+#define VALKEY_TEST_UTILS_H
 
 #define ASSERT_MSG(_x, _msg)                                                   \
     if (!(_x)) {                                                               \
@@ -69,9 +69,9 @@
 #define ASSERT_STR_STARTS_WITH(_s1, _s2)                                       \
     { assert(strncmp(_s1, _s2, strlen(_s2)) == 0); }
 
-#endif
-
 struct valkeyClusterContext;
 
 void load_valkey_version(struct valkeyClusterContext *cc);
 int valkey_version_less_than(int major, int minor);
+
+#endif /* VALKEY_TEST_UTILS_H */