diff --git a/block-storage/src/main/java/org/lucares/pdb/map/PersistentMap.java b/block-storage/src/main/java/org/lucares/pdb/map/PersistentMap.java
index c454e41..9ca4b64 100644
--- a/block-storage/src/main/java/org/lucares/pdb/map/PersistentMap.java
+++ b/block-storage/src/main/java/org/lucares/pdb/map/PersistentMap.java
@@ -153,7 +153,7 @@ public class PersistentMap<K, V> implements AutoCloseable {
 
     private final LRUCache<Long, PersistentMapDiskNode> nodeCache = new LRUCache<>(10_000);
 
-    private final LRUCache<K, V> valueCache = new LRUCache<>(10_000);
+    private final LRUCache<ByteArrayKey, V> valueCache = new LRUCache<>(10_000);
 
     // guarded by: this
     private volatile long nodeOffsetOfRootNode = -1;
@@ -209,33 +209,42 @@ public class PersistentMap<K, V> implements AutoCloseable {
 
     public synchronized V putValue(final K key, final V value) {
 
-        final V cachedValue = valueCache.get(key);
+        final byte[] encodedKey = keyEncoder.encode(key);
+        final V cachedValue = getFromValueCache(encodedKey, key);
         if (cachedValue != null && cachedValue == value) {
             return value;
         }
 
-        final byte[] encodedKey = keyEncoder.encode(key);
         final byte[] encodedValue = valueEncoder.encode(value);
         final byte[] encodedOldValue = putValue(encodedKey, encodedValue);
         final V oldValue = encodedOldValue == null ? null : valueEncoder.decode(encodedOldValue);
-        valueCache.put(key, value);
+        putIntoValueCache(encodedKey, value);
         return oldValue;
     }
 
     public synchronized V getValue(final K key) {
 
-        final V cachedValue = valueCache.get(key);
+        final byte[] encodedKey = keyEncoder.encode(key);
+        final V cachedValue = getFromValueCache(encodedKey, key);
         if (cachedValue != null) {
             return cachedValue;
         }
 
-        final byte[] encodedKey = keyEncoder.encode(key);
         final byte[] foundValue = getValue(encodedKey);
         final V result = foundValue == null ? null : valueEncoder.decode(foundValue);
-        valueCache.put(key, result);
+        putIntoValueCache(encodedKey, result);
         return result;
     }
 
+    private V getFromValueCache(final byte[] encodedKey, final K key) {
+        LOGGER.info("valueCache hit rate: {} when getting key: {}", valueCache.cacheHitRate(), key);
+        return valueCache.get(new ByteArrayKey(encodedKey));
+    }
+
+    private V putIntoValueCache(final byte[] encodedKey, final V value) {
+        return valueCache.put(new ByteArrayKey(encodedKey), value);
+    }
+
     private byte[] putValue(final byte[] key, final byte[] value) {
         final long rootNodeOffset = readNodeOffsetOfRootNode();
         final Stack<PersistentMapDiskNode> parents = new Stack<>();
@@ -303,8 +312,6 @@ public class PersistentMap<K, V> implements AutoCloseable {
     private PersistentMapDiskNode splitNode(final Stack<PersistentMapDiskNode> parents,
             final PersistentMapDiskNode node) {
 
-        // System.out.println("\n\npre split node: " + node + "\n");
-
         final long newBlockOffset = diskStore.allocateBlock(BLOCK_SIZE);
 
         final PersistentMapDiskNode newNode = node.split(newBlockOffset);
@@ -398,7 +405,7 @@ public class PersistentMap<K, V> implements AutoCloseable {
             LOGGER.trace("writing node {}", node.toString(keyEncoder.asDecoder(), valueEncoder.asDecoder()));
         }
         final long nodeOffest = node.getNodeOffset();
-        // final DiskBlock diskBlock = diskStore.getDiskBlock(nodeOffest, BLOCK_SIZE);
+
         DiskBlock diskBlock = node.getDiskBlock();
         if (diskBlock == null) {
             diskBlock = diskStore.getDiskBlock(nodeOffest, BLOCK_SIZE);