diff --git a/core/src/main/java/io/atomix/PrimitiveTypes.java b/core/src/main/java/io/atomix/PrimitiveTypes.java
index 01c2595be4..83d5769cca 100644
--- a/core/src/main/java/io/atomix/PrimitiveTypes.java
+++ b/core/src/main/java/io/atomix/PrimitiveTypes.java
@@ -107,11 +107,10 @@ public static <K, V> ConsistentMapType<K, V> map() {
   /**
    * Returns a new consistent tree map type.
    *
-   * @param <K> the key type
    * @param <V> the value type
    * @return a new consistent tree map type
    */
-  public static <K, V> ConsistentTreeMapType<K, V> treeMap() {
+  public static <V> ConsistentTreeMapType<V> treeMap() {
     return ConsistentTreeMapType.instance();
   }
 
diff --git a/core/src/main/java/io/atomix/PrimitivesService.java b/core/src/main/java/io/atomix/PrimitivesService.java
index 76d0b2b896..83cfb2c3f1 100644
--- a/core/src/main/java/io/atomix/PrimitivesService.java
+++ b/core/src/main/java/io/atomix/PrimitivesService.java
@@ -68,7 +68,7 @@ default <V> DocumentTreeBuilder<V> documentTreeBuilder(String name) {
    * @param <V> value type
    * @return builder for a async consistent tree map
    */
-  default <K, V> ConsistentTreeMapBuilder<K, V> consistentTreeMapBuilder(String name) {
+  default <V> ConsistentTreeMapBuilder<V> consistentTreeMapBuilder(String name) {
     return primitiveBuilder(name, PrimitiveTypes.treeMap());
   }
 
diff --git a/core/src/main/java/io/atomix/map/AsyncConsistentTreeMap.java b/core/src/main/java/io/atomix/map/AsyncConsistentTreeMap.java
index a9e0b5c48d..98b91c7f9b 100644
--- a/core/src/main/java/io/atomix/map/AsyncConsistentTreeMap.java
+++ b/core/src/main/java/io/atomix/map/AsyncConsistentTreeMap.java
@@ -16,9 +16,9 @@
 
 package io.atomix.map;
 
-import io.atomix.primitive.PrimitiveType;
 import io.atomix.PrimitiveTypes;
 import io.atomix.map.impl.BlockingConsistentTreeMap;
+import io.atomix.primitive.PrimitiveType;
 import io.atomix.utils.time.Versioned;
 
 import java.util.Map;
@@ -29,7 +29,7 @@
 /**
  * API for a distributed tree map implementation.
  */
-public interface AsyncConsistentTreeMap<K, V> extends AsyncConsistentMap<K, V> {
+public interface AsyncConsistentTreeMap<V> extends AsyncConsistentMap<String, V> {
 
   @Override
   default PrimitiveType primitiveType() {
@@ -41,14 +41,14 @@ default PrimitiveType primitiveType() {
    *
    * @return the key or null if none exist
    */
-  CompletableFuture<K> firstKey();
+  CompletableFuture<String> firstKey();
 
   /**
    * Return the highest key in the map.
    *
    * @return the key or null if none exist
    */
-  CompletableFuture<K> lastKey();
+  CompletableFuture<String> lastKey();
 
   /**
    * Returns the entry associated with the least key greater than or equal to
@@ -57,7 +57,7 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the entry or null if no suitable key exists
    */
-  CompletableFuture<Map.Entry<K, Versioned<V>>> ceilingEntry(K key);
+  CompletableFuture<Map.Entry<String, Versioned<V>>> ceilingEntry(String key);
 
   /**
    * Returns the entry associated with the greatest key less than or equal
@@ -66,7 +66,7 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the entry or null if no suitable key exists
    */
-  CompletableFuture<Map.Entry<K, Versioned<V>>> floorEntry(K key);
+  CompletableFuture<Map.Entry<String, Versioned<V>>> floorEntry(String key);
 
   /**
    * Returns the entry associated with the least key greater than key.
@@ -74,7 +74,7 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the entry or null if no suitable key exists
    */
-  CompletableFuture<Map.Entry<K, Versioned<V>>> higherEntry(K key);
+  CompletableFuture<Map.Entry<String, Versioned<V>>> higherEntry(String key);
 
   /**
    * Returns the entry associated with the largest key less than key.
@@ -82,35 +82,35 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the entry or null if no suitable key exists
    */
-  CompletableFuture<Map.Entry<K, Versioned<V>>> lowerEntry(K key);
+  CompletableFuture<Map.Entry<String, Versioned<V>>> lowerEntry(String key);
 
   /**
    * Return the entry associated with the lowest key in the map.
    *
    * @return the entry or null if none exist
    */
-  CompletableFuture<Map.Entry<K, Versioned<V>>> firstEntry();
+  CompletableFuture<Map.Entry<String, Versioned<V>>> firstEntry();
 
   /**
    * Return the entry associated with the highest key in the map.
    *
    * @return the entry or null if none exist
    */
-  CompletableFuture<Map.Entry<K, Versioned<V>>> lastEntry();
+  CompletableFuture<Map.Entry<String, Versioned<V>>> lastEntry();
 
   /**
    * Return and remove the entry associated with the lowest key.
    *
    * @return the entry or null if none exist
    */
-  CompletableFuture<Map.Entry<K, Versioned<V>>> pollFirstEntry();
+  CompletableFuture<Map.Entry<String, Versioned<V>>> pollFirstEntry();
 
   /**
    * Return and remove the entry associated with the highest key.
    *
    * @return the entry or null if none exist
    */
-  CompletableFuture<Map.Entry<K, Versioned<V>>> pollLastEntry();
+  CompletableFuture<Map.Entry<String, Versioned<V>>> pollLastEntry();
 
   /**
    * Return the entry associated with the greatest key less than key.
@@ -118,7 +118,7 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the entry or null if no suitable key exists
    */
-  CompletableFuture<K> lowerKey(K key);
+  CompletableFuture<String> lowerKey(String key);
 
   /**
    * Return the highest key less than or equal to key.
@@ -126,7 +126,7 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the entry or null if no suitable key exists
    */
-  CompletableFuture<K> floorKey(K key);
+  CompletableFuture<String> floorKey(String key);
 
   /**
    * Return the lowest key greater than or equal to key.
@@ -134,7 +134,7 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the entry or null if no suitable key exists
    */
-  CompletableFuture<K> ceilingKey(K key);
+  CompletableFuture<String> ceilingKey(String key);
 
   /**
    * Return the lowest key greater than key.
@@ -142,14 +142,14 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the entry or null if no suitable key exists
    */
-  CompletableFuture<K> higherKey(K key);
+  CompletableFuture<String> higherKey(String key);
 
   /**
    * Returns a navigable set of the keys in this map.
    *
    * @return a navigable key set (this may be empty)
    */
-  CompletableFuture<NavigableSet<K>> navigableKeySet();
+  CompletableFuture<NavigableSet<String>> navigableKeySet();
 
   /**
    * Returns a navigable map containing the entries from the original map
@@ -165,16 +165,17 @@ default PrimitiveType primitiveType() {
    * @return a navigable map containing entries in the specified range (this
    * may be empty)
    */
-  CompletableFuture<NavigableMap<K, V>> subMap(K upperKey,
-                                               K lowerKey,
-                                               boolean inclusiveUpper,
-                                               boolean inclusiveLower);
+  CompletableFuture<NavigableMap<String, V>> subMap(
+      String upperKey,
+      String lowerKey,
+      boolean inclusiveUpper,
+      boolean inclusiveLower);
 
-  default ConsistentTreeMap<K, V> asTreeMap() {
+  default ConsistentTreeMap<V> asTreeMap() {
     return asTreeMap(DEFAULT_OPERATION_TIMEOUT_MILLIS);
   }
 
-  default ConsistentTreeMap<K, V> asTreeMap(long timeoutMillis) {
+  default ConsistentTreeMap<V> asTreeMap(long timeoutMillis) {
     return new BlockingConsistentTreeMap<>(this, timeoutMillis);
   }
 
diff --git a/core/src/main/java/io/atomix/map/ConsistentTreeMap.java b/core/src/main/java/io/atomix/map/ConsistentTreeMap.java
index 9be777f8b2..c7f2a15044 100644
--- a/core/src/main/java/io/atomix/map/ConsistentTreeMap.java
+++ b/core/src/main/java/io/atomix/map/ConsistentTreeMap.java
@@ -16,8 +16,8 @@
 
 package io.atomix.map;
 
-import io.atomix.primitive.PrimitiveType;
 import io.atomix.PrimitiveTypes;
+import io.atomix.primitive.PrimitiveType;
 import io.atomix.utils.time.Versioned;
 
 import java.util.Map;
@@ -27,7 +27,7 @@
 /**
  * Tree map interface counterpart to {@link AsyncConsistentTreeMap}.
  */
-public interface ConsistentTreeMap<K, V> extends ConsistentMap<K, V> {
+public interface ConsistentTreeMap<V> extends ConsistentMap<String, V> {
 
   @Override
   default PrimitiveType primitiveType() {
@@ -39,14 +39,14 @@ default PrimitiveType primitiveType() {
    *
    * @return the key or null if none exist
    */
-  K firstKey();
+  String firstKey();
 
   /**
    * Returns the highest key in the map.
    *
    * @return the key or null if none exist
    */
-  K lastKey();
+  String lastKey();
 
   /**
    * Returns the entry associated with the least key greater than or equal to the key.
@@ -54,7 +54,7 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the entry or null
    */
-  Map.Entry<K, Versioned<V>> ceilingEntry(K key);
+  Map.Entry<String, Versioned<V>> ceilingEntry(String key);
 
   /**
    * Returns the entry associated with the greatest key less than or equal to key.
@@ -62,7 +62,7 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the entry or null
    */
-  Map.Entry<K, Versioned<V>> floorEntry(K key);
+  Map.Entry<String, Versioned<V>> floorEntry(String key);
 
   /**
    * Returns the entry associated with the lest key greater than key.
@@ -70,7 +70,7 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the entry or null
    */
-  Map.Entry<K, Versioned<V>> higherEntry(K key);
+  Map.Entry<String, Versioned<V>> higherEntry(String key);
 
   /**
    * Returns the entry associated with the largest key less than key.
@@ -78,35 +78,35 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the entry or null
    */
-  Map.Entry<K, Versioned<V>> lowerEntry(K key);
+  Map.Entry<String, Versioned<V>> lowerEntry(String key);
 
   /**
    * Returns the entry associated with the lowest key in the map.
    *
    * @return the entry or null
    */
-  Map.Entry<K, Versioned<V>> firstEntry();
+  Map.Entry<String, Versioned<V>> firstEntry();
 
   /**
    * Returns the entry associated with the highest key in the map.
    *
    * @return the entry or null
    */
-  Map.Entry<K, Versioned<V>> lastEntry();
+  Map.Entry<String, Versioned<V>> lastEntry();
 
   /**
    * Returns and removes the entry associated with the lowest key.
    *
    * @return the entry or null
    */
-  Map.Entry<K, Versioned<V>> pollFirstEntry();
+  Map.Entry<String, Versioned<V>> pollFirstEntry();
 
   /**
    * Returns and removes the entry associated with the highest key.
    *
    * @return the entry or null
    */
-  Map.Entry<K, Versioned<V>> pollLastEntry();
+  Map.Entry<String, Versioned<V>> pollLastEntry();
 
   /**
    * Returns the entry associated with the greatest key less than key.
@@ -114,7 +114,7 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the entry or null
    */
-  K lowerKey(K key);
+  String lowerKey(String key);
 
   /**
    * Returns the entry associated with the highest key less than or equal to key.
@@ -122,7 +122,7 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the entry or null
    */
-  K floorKey(K key);
+  String floorKey(String key);
 
   /**
    * Returns the lowest key greater than or equal to key.
@@ -130,7 +130,7 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the key or null
    */
-  K ceilingKey(K key);
+  String ceilingKey(String key);
 
   /**
    * Returns the lowest key greater than key.
@@ -138,14 +138,14 @@ default PrimitiveType primitiveType() {
    * @param key the key
    * @return the key or null
    */
-  K higherKey(K key);
+  String higherKey(String key);
 
   /**
    * Returns a navigable set of the keys in this map.
    *
    * @return a navigable key set
    */
-  NavigableSet<K> navigableKeySet();
+  NavigableSet<String> navigableKeySet();
 
   /**
    * Returns a navigable map containing the entries from the original map
@@ -161,9 +161,10 @@ default PrimitiveType primitiveType() {
    * @return a navigable map containing entries in the specified range (this
    * may be empty)
    */
-  NavigableMap<K, V> subMap(K upperKey,
-                            K lowerKey,
-                            boolean inclusiveUpper,
-                            boolean inclusiveLower);
+  NavigableMap<String, V> subMap(
+      String upperKey,
+      String lowerKey,
+      boolean inclusiveUpper,
+      boolean inclusiveLower);
 
 }
diff --git a/core/src/main/java/io/atomix/map/ConsistentTreeMapBuilder.java b/core/src/main/java/io/atomix/map/ConsistentTreeMapBuilder.java
index b7bef796cd..359e5c6e7f 100644
--- a/core/src/main/java/io/atomix/map/ConsistentTreeMapBuilder.java
+++ b/core/src/main/java/io/atomix/map/ConsistentTreeMapBuilder.java
@@ -16,12 +16,12 @@
 
 package io.atomix.map;
 
+import io.atomix.PrimitiveTypes;
 import io.atomix.primitive.Consistency;
 import io.atomix.primitive.DistributedPrimitiveBuilder;
 import io.atomix.primitive.Persistence;
 import io.atomix.primitive.PrimitiveProtocol;
 import io.atomix.primitive.Replication;
-import io.atomix.PrimitiveTypes;
 import io.atomix.protocols.backup.MultiPrimaryProtocol;
 import io.atomix.protocols.raft.RaftProtocol;
 import io.atomix.protocols.raft.ReadConsistency;
@@ -31,8 +31,8 @@
 /**
  * Builder for {@link ConsistentTreeMap}.
  */
-public abstract class ConsistentTreeMapBuilder<K, V>
-    extends DistributedPrimitiveBuilder<ConsistentTreeMapBuilder<K, V>, ConsistentTreeMap<K, V>, AsyncConsistentTreeMap<K, V>> {
+public abstract class ConsistentTreeMapBuilder<V>
+    extends DistributedPrimitiveBuilder<ConsistentTreeMapBuilder<V>, ConsistentTreeMap<V>, AsyncConsistentTreeMap<V>> {
 
   public ConsistentTreeMapBuilder(String name) {
     super(PrimitiveTypes.treeMap(), name);
@@ -100,7 +100,7 @@ private PrimitiveProtocol newMultiPrimaryProtocol(Consistency consistency, Repli
   }
 
   @Override
-  public ConsistentTreeMap<K, V> build() {
+  public ConsistentTreeMap<V> build() {
     return buildAsync().asTreeMap();
   }
 }
diff --git a/core/src/main/java/io/atomix/map/ConsistentTreeMapType.java b/core/src/main/java/io/atomix/map/ConsistentTreeMapType.java
index 146bf5acb8..683c5f79e5 100644
--- a/core/src/main/java/io/atomix/map/ConsistentTreeMapType.java
+++ b/core/src/main/java/io/atomix/map/ConsistentTreeMapType.java
@@ -15,28 +15,28 @@
  */
 package io.atomix.map;
 
+import io.atomix.map.impl.ConsistentTreeMapProxyBuilder;
+import io.atomix.map.impl.ConsistentTreeMapService;
 import io.atomix.primitive.PrimitiveManagementService;
 import io.atomix.primitive.PrimitiveType;
 import io.atomix.primitive.service.PrimitiveService;
-import io.atomix.map.impl.ConsistentTreeMapProxyBuilder;
-import io.atomix.map.impl.ConsistentTreeMapService;
 
 import static com.google.common.base.MoreObjects.toStringHelper;
 
 /**
  * Consistent tree map primitive type.
  */
-public class ConsistentTreeMapType<K, V> implements PrimitiveType<ConsistentTreeMapBuilder<K, V>, ConsistentTreeMap<K, V>, AsyncConsistentTreeMap<K, V>> {
+public class ConsistentTreeMapType<V>
+    implements PrimitiveType<ConsistentTreeMapBuilder<V>, ConsistentTreeMap<V>, AsyncConsistentTreeMap<V>> {
   private static final String NAME = "CONSISTENT_TREEMAP";
 
   /**
    * Returns a new consistent tree map type.
    *
-   * @param <K> the key type
    * @param <V> the value type
    * @return a new consistent tree map type
    */
-  public static <K, V> ConsistentTreeMapType<K, V> instance() {
+  public static <V> ConsistentTreeMapType<V> instance() {
     return new ConsistentTreeMapType<>();
   }
 
@@ -54,7 +54,7 @@ public PrimitiveService newService() {
   }
 
   @Override
-  public ConsistentTreeMapBuilder<K, V> newPrimitiveBuilder(String name, PrimitiveManagementService managementService) {
+  public ConsistentTreeMapBuilder<V> newPrimitiveBuilder(String name, PrimitiveManagementService managementService) {
     return new ConsistentTreeMapProxyBuilder<>(name, managementService);
   }
 
diff --git a/core/src/main/java/io/atomix/map/impl/BlockingConsistentTreeMap.java b/core/src/main/java/io/atomix/map/impl/BlockingConsistentTreeMap.java
index 0051993909..b6f634db26 100644
--- a/core/src/main/java/io/atomix/map/impl/BlockingConsistentTreeMap.java
+++ b/core/src/main/java/io/atomix/map/impl/BlockingConsistentTreeMap.java
@@ -17,12 +17,12 @@
 package io.atomix.map.impl;
 
 import com.google.common.base.Throwables;
-import io.atomix.primitive.Synchronous;
 import io.atomix.map.AsyncConsistentTreeMap;
 import io.atomix.map.ConsistentMapBackedJavaMap;
 import io.atomix.map.ConsistentMapException;
 import io.atomix.map.ConsistentTreeMap;
 import io.atomix.map.MapEventListener;
+import io.atomix.primitive.Synchronous;
 import io.atomix.utils.time.Versioned;
 
 import java.util.Collection;
@@ -42,14 +42,14 @@
 /**
  * Implementation of the {@link ConsistentTreeMap} interface.
  */
-public class BlockingConsistentTreeMap<K, V>
-    extends Synchronous<AsyncConsistentTreeMap<K, V>>
-    implements ConsistentTreeMap<K, V> {
-  private final AsyncConsistentTreeMap<K, V> treeMap;
+public class BlockingConsistentTreeMap<V>
+    extends Synchronous<AsyncConsistentTreeMap<V>>
+    implements ConsistentTreeMap<V> {
+  private final AsyncConsistentTreeMap<V> treeMap;
   private final long operationTimeoutMillis;
-  private Map<K, V> javaMap;
+  private Map<String, V> javaMap;
 
-  public BlockingConsistentTreeMap(AsyncConsistentTreeMap<K, V> treeMap, long operationTimeoutMillis) {
+  public BlockingConsistentTreeMap(AsyncConsistentTreeMap<V> treeMap, long operationTimeoutMillis) {
     super(treeMap);
     this.treeMap = treeMap;
     this.operationTimeoutMillis = operationTimeoutMillis;
@@ -70,77 +70,77 @@ private <T> T complete(CompletableFuture<T> future) {
   }
 
   @Override
-  public K firstKey() {
+  public String firstKey() {
     return complete(treeMap.firstKey());
   }
 
   @Override
-  public K lastKey() {
+  public String lastKey() {
     return complete(treeMap.lastKey());
   }
 
   @Override
-  public Map.Entry<K, Versioned<V>> ceilingEntry(K key) {
+  public Map.Entry<String, Versioned<V>> ceilingEntry(String key) {
     return complete(treeMap.ceilingEntry(key));
   }
 
   @Override
-  public Map.Entry<K, Versioned<V>> floorEntry(K key) {
+  public Map.Entry<String, Versioned<V>> floorEntry(String key) {
     return complete(treeMap.floorEntry(key));
   }
 
   @Override
-  public Map.Entry<K, Versioned<V>> higherEntry(K key) {
+  public Map.Entry<String, Versioned<V>> higherEntry(String key) {
     return complete(treeMap.higherEntry(key));
   }
 
   @Override
-  public Map.Entry<K, Versioned<V>> lowerEntry(K key) {
+  public Map.Entry<String, Versioned<V>> lowerEntry(String key) {
     return complete(treeMap.lowerEntry(key));
   }
 
   @Override
-  public Map.Entry<K, Versioned<V>> firstEntry() {
+  public Map.Entry<String, Versioned<V>> firstEntry() {
     return complete(treeMap.firstEntry());
   }
 
   @Override
-  public Map.Entry<K, Versioned<V>> lastEntry() {
+  public Map.Entry<String, Versioned<V>> lastEntry() {
     return complete(treeMap.lastEntry());
   }
 
   @Override
-  public Map.Entry<K, Versioned<V>> pollFirstEntry() {
+  public Map.Entry<String, Versioned<V>> pollFirstEntry() {
     return complete(treeMap.pollFirstEntry());
   }
 
   @Override
-  public Map.Entry<K, Versioned<V>> pollLastEntry() {
+  public Map.Entry<String, Versioned<V>> pollLastEntry() {
     return complete(treeMap.pollLastEntry());
   }
 
   @Override
-  public K lowerKey(K key) {
+  public String lowerKey(String key) {
     return complete(treeMap.lowerKey(key));
   }
 
   @Override
-  public K floorKey(K key) {
+  public String floorKey(String key) {
     return complete(treeMap.floorKey(key));
   }
 
   @Override
-  public K ceilingKey(K key) {
+  public String ceilingKey(String key) {
     return complete(treeMap.ceilingKey(key));
   }
 
   @Override
-  public K higherKey(K key) {
+  public String higherKey(String key) {
     return complete(treeMap.higherKey(key));
   }
 
   @Override
-  public NavigableSet<K> navigableKeySet() {
+  public NavigableSet<String> navigableKeySet() {
     return complete(treeMap.navigableKeySet());
   }
 
@@ -155,7 +155,7 @@ public boolean isEmpty() {
   }
 
   @Override
-  public boolean containsKey(K key) {
+  public boolean containsKey(String key) {
     return complete(treeMap.containsKey(key));
   }
 
@@ -165,49 +165,49 @@ public boolean containsValue(V value) {
   }
 
   @Override
-  public Versioned<V> get(K key) {
+  public Versioned<V> get(String key) {
     return complete(treeMap.get(key));
   }
 
   @Override
-  public Versioned<V> getOrDefault(K key, V defaultValue) {
+  public Versioned<V> getOrDefault(String key, V defaultValue) {
     return complete(treeMap.getOrDefault(key, defaultValue));
   }
 
   @Override
-  public Versioned<V> computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
+  public Versioned<V> computeIfAbsent(String key, Function<? super String, ? extends V> mappingFunction) {
     return complete(treeMap.computeIfAbsent(key, mappingFunction));
   }
 
   @Override
-  public Versioned<V> compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+  public Versioned<V> compute(String key, BiFunction<? super String, ? super V, ? extends V> remappingFunction) {
     return complete(treeMap.compute(key, remappingFunction));
   }
 
   @Override
-  public Versioned<V> computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+  public Versioned<V> computeIfPresent(String key, BiFunction<? super String, ? super V, ? extends V> remappingFunction) {
     return complete(treeMap.computeIfPresent(key, remappingFunction));
   }
 
   @Override
-  public Versioned<V> computeIf(K key,
+  public Versioned<V> computeIf(String key,
                                 Predicate<? super V> condition,
-                                BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+                                BiFunction<? super String, ? super V, ? extends V> remappingFunction) {
     return complete(treeMap.computeIf(key, condition, remappingFunction));
   }
 
   @Override
-  public Versioned<V> put(K key, V value) {
+  public Versioned<V> put(String key, V value) {
     return complete(treeMap.put(key, value));
   }
 
   @Override
-  public Versioned<V> putAndGet(K key, V value) {
+  public Versioned<V> putAndGet(String key, V value) {
     return complete(treeMap.putAndGet(key, value));
   }
 
   @Override
-  public Versioned<V> remove(K key) {
+  public Versioned<V> remove(String key) {
     return complete(treeMap.remove(key));
   }
 
@@ -217,7 +217,7 @@ public void clear() {
   }
 
   @Override
-  public Set<K> keySet() {
+  public Set<String> keySet() {
     return complete(treeMap.keySet());
   }
 
@@ -227,52 +227,52 @@ public Collection<Versioned<V>> values() {
   }
 
   @Override
-  public Set<Map.Entry<K, Versioned<V>>> entrySet() {
+  public Set<Map.Entry<String, Versioned<V>>> entrySet() {
     return complete(treeMap.entrySet());
   }
 
   @Override
-  public Versioned<V> putIfAbsent(K key, V value) {
+  public Versioned<V> putIfAbsent(String key, V value) {
     return complete(treeMap.putIfAbsent(key, value));
   }
 
   @Override
-  public boolean remove(K key, V value) {
+  public boolean remove(String key, V value) {
     return complete(treeMap.remove(key, value));
   }
 
   @Override
-  public boolean remove(K key, long version) {
+  public boolean remove(String key, long version) {
     return complete(treeMap.remove(key, version));
   }
 
   @Override
-  public Versioned<V> replace(K key, V value) {
+  public Versioned<V> replace(String key, V value) {
     return complete(treeMap.replace(key, value));
   }
 
   @Override
-  public boolean replace(K key, V oldValue, V newValue) {
+  public boolean replace(String key, V oldValue, V newValue) {
     return complete(treeMap.replace(key, oldValue, newValue));
   }
 
   @Override
-  public boolean replace(K key, long oldVersion, V newValue) {
+  public boolean replace(String key, long oldVersion, V newValue) {
     return complete(treeMap.replace(key, oldVersion, newValue));
   }
 
   @Override
-  public void addListener(MapEventListener<K, V> listener, Executor executor) {
+  public void addListener(MapEventListener<String, V> listener, Executor executor) {
     complete(treeMap.addListener(listener, executor));
   }
 
   @Override
-  public void removeListener(MapEventListener<K, V> listener) {
+  public void removeListener(MapEventListener<String, V> listener) {
     complete(treeMap.removeListener(listener));
   }
 
   @Override
-  public Map<K, V> asJavaMap() {
+  public Map<String, V> asJavaMap() {
     synchronized (this) {
       if (javaMap == null) {
         javaMap = new ConsistentMapBackedJavaMap<>(this);
@@ -282,7 +282,7 @@ public Map<K, V> asJavaMap() {
   }
 
   @Override
-  public NavigableMap<K, V> subMap(K upperKey, K lowerKey, boolean inclusiveUpper, boolean inclusiveLower) {
+  public NavigableMap<String, V> subMap(String upperKey, String lowerKey, boolean inclusiveUpper, boolean inclusiveLower) {
     return complete(treeMap.subMap(upperKey, lowerKey,
         inclusiveUpper, inclusiveLower));
   }
diff --git a/core/src/main/java/io/atomix/map/impl/ConsistentTreeMapProxy.java b/core/src/main/java/io/atomix/map/impl/ConsistentTreeMapProxy.java
index 6b9c48a47a..3147ee27af 100644
--- a/core/src/main/java/io/atomix/map/impl/ConsistentTreeMapProxy.java
+++ b/core/src/main/java/io/atomix/map/impl/ConsistentTreeMapProxy.java
@@ -16,7 +16,6 @@
 
 package io.atomix.map.impl;
 
-import io.atomix.primitive.proxy.PrimitiveProxy;
 import io.atomix.map.AsyncConsistentTreeMap;
 import io.atomix.map.impl.ConsistentTreeMapOperations.CeilingEntry;
 import io.atomix.map.impl.ConsistentTreeMapOperations.CeilingKey;
@@ -26,6 +25,7 @@
 import io.atomix.map.impl.ConsistentTreeMapOperations.HigherKey;
 import io.atomix.map.impl.ConsistentTreeMapOperations.LowerEntry;
 import io.atomix.map.impl.ConsistentTreeMapOperations.LowerKey;
+import io.atomix.primitive.proxy.PrimitiveProxy;
 import io.atomix.transaction.TransactionId;
 import io.atomix.transaction.TransactionLog;
 import io.atomix.utils.serializer.KryoNamespace;
@@ -58,7 +58,7 @@
 /**
  * Implementation of {@link io.atomix.map.AsyncConsistentTreeMap}.
  */
-public class ConsistentTreeMapProxy extends ConsistentMapProxy implements AsyncConsistentTreeMap<String, byte[]> {
+public class ConsistentTreeMapProxy extends ConsistentMapProxy implements AsyncConsistentTreeMap<byte[]> {
   private static final Serializer SERIALIZER = Serializer.using(KryoNamespace.builder()
       .register(KryoNamespaces.BASIC)
       .register(ConsistentMapOperations.NAMESPACE)
diff --git a/core/src/main/java/io/atomix/map/impl/ConsistentTreeMapProxyBuilder.java b/core/src/main/java/io/atomix/map/impl/ConsistentTreeMapProxyBuilder.java
index 801cbb4132..9c1d0e5f75 100644
--- a/core/src/main/java/io/atomix/map/impl/ConsistentTreeMapProxyBuilder.java
+++ b/core/src/main/java/io/atomix/map/impl/ConsistentTreeMapProxyBuilder.java
@@ -15,12 +15,11 @@
  */
 package io.atomix.map.impl;
 
-import com.google.common.io.BaseEncoding;
+import io.atomix.map.AsyncConsistentTreeMap;
+import io.atomix.map.ConsistentTreeMapBuilder;
 import io.atomix.primitive.PrimitiveManagementService;
 import io.atomix.primitive.PrimitiveProtocol;
 import io.atomix.primitive.proxy.PrimitiveProxy;
-import io.atomix.map.AsyncConsistentTreeMap;
-import io.atomix.map.ConsistentTreeMapBuilder;
 import io.atomix.utils.serializer.Serializer;
 
 import static com.google.common.base.Preconditions.checkNotNull;
@@ -30,7 +29,7 @@
  *
  * @param <V> type for map value
  */
-public class ConsistentTreeMapProxyBuilder<K, V> extends ConsistentTreeMapBuilder<K, V> {
+public class ConsistentTreeMapProxyBuilder<V> extends ConsistentTreeMapBuilder<V> {
   private final PrimitiveManagementService managementService;
 
   public ConsistentTreeMapProxyBuilder(String name, PrimitiveManagementService managementService) {
@@ -38,21 +37,19 @@ public ConsistentTreeMapProxyBuilder(String name, PrimitiveManagementService man
     this.managementService = checkNotNull(managementService);
   }
 
-  protected AsyncConsistentTreeMap<K, V> newTreeMap(PrimitiveProxy proxy) {
+  protected AsyncConsistentTreeMap<V> newTreeMap(PrimitiveProxy proxy) {
     ConsistentTreeMapProxy rawMap = new ConsistentTreeMapProxy(proxy.open().join());
 
     Serializer serializer = serializer();
     return new TranscodingAsyncConsistentTreeMap<>(
         rawMap,
-        key -> BaseEncoding.base16().encode(serializer.encode(key)),
-        string -> serializer.decode(BaseEncoding.base16().decode(string)),
         value -> value == null ? null : serializer.encode(value),
         bytes -> serializer.decode(bytes));
   }
 
   @Override
   @SuppressWarnings("unchecked")
-  public AsyncConsistentTreeMap<K, V> buildAsync() {
+  public AsyncConsistentTreeMap<V> buildAsync() {
     PrimitiveProtocol protocol = protocol();
     return newTreeMap(managementService.getPartitionService()
         .getPartitionGroup(protocol)
diff --git a/core/src/main/java/io/atomix/map/impl/DelegatingAsyncConsistentTreeMap.java b/core/src/main/java/io/atomix/map/impl/DelegatingAsyncConsistentTreeMap.java
index 1d884efe38..bf77c8971d 100644
--- a/core/src/main/java/io/atomix/map/impl/DelegatingAsyncConsistentTreeMap.java
+++ b/core/src/main/java/io/atomix/map/impl/DelegatingAsyncConsistentTreeMap.java
@@ -16,9 +16,9 @@
 
 package io.atomix.map.impl;
 
-import io.atomix.primitive.impl.DelegatingDistributedPrimitive;
 import io.atomix.map.AsyncConsistentTreeMap;
 import io.atomix.map.MapEventListener;
+import io.atomix.primitive.impl.DelegatingDistributedPrimitive;
 import io.atomix.transaction.TransactionId;
 import io.atomix.transaction.TransactionLog;
 import io.atomix.utils.time.Version;
@@ -40,97 +40,97 @@
  * A {@link AsyncConsistentTreeMap} that delegates control to another instance
  * of {@link AsyncConsistentTreeMap}.
  */
-public class DelegatingAsyncConsistentTreeMap<K, V>
+public class DelegatingAsyncConsistentTreeMap<V>
     extends DelegatingDistributedPrimitive
-    implements AsyncConsistentTreeMap<K, V> {
+    implements AsyncConsistentTreeMap<V> {
 
-  private final AsyncConsistentTreeMap<K, V> delegateMap;
+  private final AsyncConsistentTreeMap<V> delegateMap;
 
-  DelegatingAsyncConsistentTreeMap(AsyncConsistentTreeMap<K, V> delegateMap) {
+  DelegatingAsyncConsistentTreeMap(AsyncConsistentTreeMap<V> delegateMap) {
     super(delegateMap);
     this.delegateMap = checkNotNull(delegateMap,
         "delegate map cannot be null");
   }
 
   @Override
-  public CompletableFuture<K> firstKey() {
+  public CompletableFuture<String> firstKey() {
     return delegateMap.firstKey();
   }
 
   @Override
-  public CompletableFuture<K> lastKey() {
+  public CompletableFuture<String> lastKey() {
     return delegateMap.lastKey();
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K, Versioned<V>>> ceilingEntry(K key) {
+  public CompletableFuture<Map.Entry<String, Versioned<V>>> ceilingEntry(String key) {
     return delegateMap.ceilingEntry(key);
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K, Versioned<V>>> floorEntry(K key) {
+  public CompletableFuture<Map.Entry<String, Versioned<V>>> floorEntry(String key) {
     return delegateMap.floorEntry(key);
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K, Versioned<V>>> higherEntry(K key) {
+  public CompletableFuture<Map.Entry<String, Versioned<V>>> higherEntry(String key) {
     return delegateMap.higherEntry(key);
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K, Versioned<V>>> lowerEntry(K key) {
+  public CompletableFuture<Map.Entry<String, Versioned<V>>> lowerEntry(String key) {
     return delegateMap.lowerEntry(key);
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K, Versioned<V>>> firstEntry() {
+  public CompletableFuture<Map.Entry<String, Versioned<V>>> firstEntry() {
     return delegateMap.firstEntry();
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K, Versioned<V>>> lastEntry() {
+  public CompletableFuture<Map.Entry<String, Versioned<V>>> lastEntry() {
     return delegateMap.lastEntry();
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K, Versioned<V>>> pollFirstEntry() {
+  public CompletableFuture<Map.Entry<String, Versioned<V>>> pollFirstEntry() {
     return delegateMap.pollFirstEntry();
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K, Versioned<V>>> pollLastEntry() {
+  public CompletableFuture<Map.Entry<String, Versioned<V>>> pollLastEntry() {
     return delegateMap.pollLastEntry();
   }
 
   @Override
-  public CompletableFuture<K> lowerKey(K key) {
+  public CompletableFuture<String> lowerKey(String key) {
     return delegateMap.lowerKey(key);
   }
 
   @Override
-  public CompletableFuture<K> floorKey(K key) {
+  public CompletableFuture<String> floorKey(String key) {
     return delegateMap.floorKey(key);
   }
 
   @Override
-  public CompletableFuture<K> ceilingKey(K key) {
+  public CompletableFuture<String> ceilingKey(String key) {
     return delegateMap.ceilingKey(key);
   }
 
   @Override
-  public CompletableFuture<K> higherKey(K key) {
+  public CompletableFuture<String> higherKey(String key) {
     return delegateMap.higherKey(key);
   }
 
   @Override
-  public CompletableFuture<NavigableSet<K>> navigableKeySet() {
+  public CompletableFuture<NavigableSet<String>> navigableKeySet() {
     return delegateMap.navigableKeySet();
   }
 
   @Override
-  public CompletableFuture<NavigableMap<K, V>> subMap(
-      K upperKey,
-      K lowerKey,
+  public CompletableFuture<NavigableMap<String, V>> subMap(
+      String upperKey,
+      String lowerKey,
       boolean inclusiveUpper,
       boolean inclusiveLower) {
     return delegateMap.subMap(upperKey, lowerKey,
@@ -143,7 +143,7 @@ public CompletableFuture<Integer> size() {
   }
 
   @Override
-  public CompletableFuture<Boolean> containsKey(K key) {
+  public CompletableFuture<Boolean> containsKey(String key) {
     return delegateMap.containsKey(key);
   }
 
@@ -153,36 +153,36 @@ public CompletableFuture<Boolean> containsValue(V value) {
   }
 
   @Override
-  public CompletableFuture<Versioned<V>> get(K key) {
+  public CompletableFuture<Versioned<V>> get(String key) {
     return delegateMap.get(key);
   }
 
   @Override
-  public CompletableFuture<Versioned<V>> getOrDefault(K key, V defaultValue) {
+  public CompletableFuture<Versioned<V>> getOrDefault(String key, V defaultValue) {
     return delegateMap.getOrDefault(key, defaultValue);
   }
 
   @Override
   public CompletableFuture<Versioned<V>> computeIf(
-      K key,
+      String key,
       Predicate<? super V> condition,
-      BiFunction<? super K, ? super V,
+      BiFunction<? super String, ? super V,
           ? extends V> remappingFunction) {
     return delegateMap.computeIf(key, condition, remappingFunction);
   }
 
   @Override
-  public CompletableFuture<Versioned<V>> put(K key, V value) {
+  public CompletableFuture<Versioned<V>> put(String key, V value) {
     return delegateMap.put(key, value);
   }
 
   @Override
-  public CompletableFuture<Versioned<V>> putAndGet(K key, V value) {
+  public CompletableFuture<Versioned<V>> putAndGet(String key, V value) {
     return delegateMap.putAndGet(key, value);
   }
 
   @Override
-  public CompletableFuture<Versioned<V>> remove(K key) {
+  public CompletableFuture<Versioned<V>> remove(String key) {
     return delegateMap.remove(key);
   }
 
@@ -192,7 +192,7 @@ public CompletableFuture<Void> clear() {
   }
 
   @Override
-  public CompletableFuture<Set<K>> keySet() {
+  public CompletableFuture<Set<String>> keySet() {
     return delegateMap.keySet();
   }
 
@@ -202,51 +202,51 @@ public CompletableFuture<Collection<Versioned<V>>> values() {
   }
 
   @Override
-  public CompletableFuture<Set<Map.Entry<K, Versioned<V>>>> entrySet() {
+  public CompletableFuture<Set<Map.Entry<String, Versioned<V>>>> entrySet() {
     return delegateMap.entrySet();
   }
 
   @Override
-  public CompletableFuture<Versioned<V>> putIfAbsent(K key, V value) {
+  public CompletableFuture<Versioned<V>> putIfAbsent(String key, V value) {
     return delegateMap.putIfAbsent(key, value);
   }
 
   @Override
-  public CompletableFuture<Boolean> remove(K key, V value) {
+  public CompletableFuture<Boolean> remove(String key, V value) {
     return delegateMap.remove(key, value);
   }
 
   @Override
-  public CompletableFuture<Boolean> remove(K key, long version) {
+  public CompletableFuture<Boolean> remove(String key, long version) {
     return delegateMap.remove(key, version);
   }
 
   @Override
-  public CompletableFuture<Versioned<V>> replace(K key, V value) {
+  public CompletableFuture<Versioned<V>> replace(String key, V value) {
     return delegateMap.replace(key, value);
   }
 
   @Override
-  public CompletableFuture<Boolean> replace(K key, V oldValue,
+  public CompletableFuture<Boolean> replace(String key, V oldValue,
                                             V newValue) {
     return delegateMap.replace(key, oldValue, newValue);
   }
 
   @Override
-  public CompletableFuture<Boolean> replace(K key, long oldVersion,
+  public CompletableFuture<Boolean> replace(String key, long oldVersion,
                                             V newValue) {
     return delegateMap.replace(key, oldVersion, newValue);
   }
 
   @Override
   public CompletableFuture<Void> addListener(
-      MapEventListener<K, V> listener, Executor executor) {
+      MapEventListener<String, V> listener, Executor executor) {
     return delegateMap.addListener(listener, executor);
   }
 
   @Override
   public CompletableFuture<Void> removeListener(
-      MapEventListener<K, V> listener) {
+      MapEventListener<String, V> listener) {
     return delegateMap.removeListener(listener);
   }
 
@@ -256,12 +256,12 @@ public CompletableFuture<Version> begin(TransactionId transactionId) {
   }
 
   @Override
-  public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<K, V>> transactionLog) {
+  public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<String, V>> transactionLog) {
     return delegateMap.prepare(transactionLog);
   }
 
   @Override
-  public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<K, V>> transactionLog) {
+  public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<String, V>> transactionLog) {
     return delegateMap.prepareAndCommit(transactionLog);
   }
 
diff --git a/core/src/main/java/io/atomix/map/impl/TranscodingAsyncConsistentTreeMap.java b/core/src/main/java/io/atomix/map/impl/TranscodingAsyncConsistentTreeMap.java
index 011eab146f..9a38d100bf 100644
--- a/core/src/main/java/io/atomix/map/impl/TranscodingAsyncConsistentTreeMap.java
+++ b/core/src/main/java/io/atomix/map/impl/TranscodingAsyncConsistentTreeMap.java
@@ -31,7 +31,6 @@
 import java.util.NavigableMap;
 import java.util.NavigableSet;
 import java.util.Set;
-import java.util.TreeSet;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
 import java.util.function.BiFunction;
@@ -47,127 +46,110 @@
  * @param <V2> value type of other map
  * @param <V1> value type of this map
  */
-public class TranscodingAsyncConsistentTreeMap<K1, V1, K2, V2> implements AsyncConsistentTreeMap<K1, V1> {
-  private final AsyncConsistentTreeMap<K2, V2> backingMap;
-  private final Function<K1, K2> keyEncoder;
-  private final Function<K2, K1> keyDecoder;
+public class TranscodingAsyncConsistentTreeMap<V1, V2> implements AsyncConsistentTreeMap<V1> {
+  private final AsyncConsistentTreeMap<V2> backingMap;
   private final Function<V2, V1> valueDecoder;
   private final Function<V1, V2> valueEncoder;
   private final Function<Versioned<V2>, Versioned<V1>> versionedValueTransform;
-  private final Map<MapEventListener<K1, V1>, InternalBackingMapEventListener> listeners = Maps.newIdentityHashMap();
+  private final Map<MapEventListener<String, V1>, InternalBackingMapEventListener> listeners = Maps.newIdentityHashMap();
 
   public TranscodingAsyncConsistentTreeMap(
-      AsyncConsistentTreeMap<K2, V2> backingMap,
-      Function<K1, K2> keyEncoder,
-      Function<K2, K1> keyDecoder,
+      AsyncConsistentTreeMap<V2> backingMap,
       Function<V1, V2> valueEncoder,
       Function<V2, V1> valueDecoder) {
     this.backingMap = backingMap;
-    this.keyEncoder = k -> k == null ? null : keyEncoder.apply(k);
-    this.keyDecoder = k -> k == null ? null : keyDecoder.apply(k);
     this.valueEncoder = v -> v == null ? null : valueEncoder.apply(v);
     this.valueDecoder = v -> v == null ? null : valueDecoder.apply(v);
     this.versionedValueTransform = v -> v == null ? null : v.map(valueDecoder);
   }
 
   @Override
-  public CompletableFuture<K1> firstKey() {
-    return backingMap.firstKey().thenApply(keyDecoder);
+  public CompletableFuture<String> firstKey() {
+    return backingMap.firstKey();
   }
 
   @Override
-  public CompletableFuture<K1> lastKey() {
-    return backingMap.lastKey().thenApply(keyDecoder);
+  public CompletableFuture<String> lastKey() {
+    return backingMap.lastKey();
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K1, Versioned<V1>>> ceilingEntry(K1 key) {
-    return backingMap.ceilingEntry(keyEncoder.apply(key))
-        .thenApply(entry -> entry != null ? Maps.immutableEntry(keyDecoder.apply(entry.getKey()), versionedValueTransform.apply(entry.getValue())) : null);
+  public CompletableFuture<Map.Entry<String, Versioned<V1>>> ceilingEntry(String key) {
+    return backingMap.ceilingEntry(key)
+        .thenApply(entry -> entry != null ? Maps.immutableEntry(entry.getKey(), versionedValueTransform.apply(entry.getValue())) : null);
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K1, Versioned<V1>>> floorEntry(K1 key) {
-    return backingMap.floorEntry(keyEncoder.apply(key))
-        .thenApply(entry -> entry != null ? Maps.immutableEntry(keyDecoder.apply(entry.getKey()), versionedValueTransform.apply(entry.getValue())) : null);
+  public CompletableFuture<Map.Entry<String, Versioned<V1>>> floorEntry(String key) {
+    return backingMap.floorEntry(key)
+        .thenApply(entry -> entry != null ? Maps.immutableEntry(entry.getKey(), versionedValueTransform.apply(entry.getValue())) : null);
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K1, Versioned<V1>>> higherEntry(K1 key) {
-    return backingMap.higherEntry(keyEncoder.apply(key))
-        .thenApply(entry -> entry != null ? Maps.immutableEntry(keyDecoder.apply(entry.getKey()), versionedValueTransform.apply(entry.getValue())) : null);
+  public CompletableFuture<Map.Entry<String, Versioned<V1>>> higherEntry(String key) {
+    return backingMap.higherEntry(key)
+        .thenApply(entry -> entry != null ? Maps.immutableEntry(entry.getKey(), versionedValueTransform.apply(entry.getValue())) : null);
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K1, Versioned<V1>>> lowerEntry(K1 key) {
-    return backingMap.lowerEntry(keyEncoder.apply(key))
-        .thenApply(entry -> entry != null ? Maps.immutableEntry(keyDecoder.apply(entry.getKey()), versionedValueTransform.apply(entry.getValue())) : null);
+  public CompletableFuture<Map.Entry<String, Versioned<V1>>> lowerEntry(String key) {
+    return backingMap.lowerEntry(key)
+        .thenApply(entry -> entry != null ? Maps.immutableEntry(entry.getKey(), versionedValueTransform.apply(entry.getValue())) : null);
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K1, Versioned<V1>>> firstEntry() {
+  public CompletableFuture<Map.Entry<String, Versioned<V1>>> firstEntry() {
     return backingMap.firstEntry()
-        .thenApply(entry -> entry != null ? Maps.immutableEntry(keyDecoder.apply(entry.getKey()), versionedValueTransform.apply(entry.getValue())) : null);
+        .thenApply(entry -> entry != null ? Maps.immutableEntry(entry.getKey(), versionedValueTransform.apply(entry.getValue())) : null);
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K1, Versioned<V1>>> lastEntry() {
+  public CompletableFuture<Map.Entry<String, Versioned<V1>>> lastEntry() {
     return backingMap.lastEntry()
-        .thenApply(entry -> entry != null ? Maps.immutableEntry(keyDecoder.apply(entry.getKey()), versionedValueTransform.apply(entry.getValue())) : null);
+        .thenApply(entry -> entry != null ? Maps.immutableEntry(entry.getKey(), versionedValueTransform.apply(entry.getValue())) : null);
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K1, Versioned<V1>>> pollFirstEntry() {
+  public CompletableFuture<Map.Entry<String, Versioned<V1>>> pollFirstEntry() {
     return backingMap.pollFirstEntry()
-        .thenApply(entry -> entry != null ? Maps.immutableEntry(keyDecoder.apply(entry.getKey()), versionedValueTransform.apply(entry.getValue())) : null);
+        .thenApply(entry -> entry != null ? Maps.immutableEntry(entry.getKey(), versionedValueTransform.apply(entry.getValue())) : null);
   }
 
   @Override
-  public CompletableFuture<Map.Entry<K1, Versioned<V1>>> pollLastEntry() {
+  public CompletableFuture<Map.Entry<String, Versioned<V1>>> pollLastEntry() {
     return backingMap.pollLastEntry()
-        .thenApply(entry -> entry != null ? Maps.immutableEntry(keyDecoder.apply(entry.getKey()), versionedValueTransform.apply(entry.getValue())) : null);
+        .thenApply(entry -> entry != null ? Maps.immutableEntry(entry.getKey(), versionedValueTransform.apply(entry.getValue())) : null);
   }
 
   @Override
-  public CompletableFuture<K1> lowerKey(K1 key) {
-    return backingMap.lowerKey(keyEncoder.apply(key))
-        .thenApply(keyDecoder);
+  public CompletableFuture<String> lowerKey(String key) {
+    return backingMap.lowerKey(key);
   }
 
   @Override
-  public CompletableFuture<K1> floorKey(K1 key) {
-    return backingMap.floorKey(keyEncoder.apply(key))
-        .thenApply(keyDecoder);
+  public CompletableFuture<String> floorKey(String key) {
+    return backingMap.floorKey(key);
   }
 
   @Override
-  public CompletableFuture<K1> ceilingKey(K1 key) {
-    return backingMap.ceilingKey(keyEncoder.apply(key))
-        .thenApply(keyDecoder);
+  public CompletableFuture<String> ceilingKey(String key) {
+    return backingMap.ceilingKey(key);
   }
 
   @Override
-  public CompletableFuture<K1> higherKey(K1 key) {
-    return backingMap.higherKey(keyEncoder.apply(key))
-        .thenApply(keyDecoder);
+  public CompletableFuture<String> higherKey(String key) {
+    return backingMap.higherKey(key);
   }
 
   @Override
-  public CompletableFuture<NavigableSet<K1>> navigableKeySet() {
-    return backingMap.navigableKeySet()
-        .thenApply(set -> set.stream()
-        .map(keyDecoder)
-        .collect(Collectors.toCollection(TreeSet::new)));
+  public CompletableFuture<NavigableSet<String>> navigableKeySet() {
+    return backingMap.navigableKeySet();
   }
 
   @Override
-  public CompletableFuture<NavigableMap<K1, V1>> subMap(
-      K1 upperKey,
-      K1 lowerKey,
-      boolean inclusiveUpper,
-      boolean inclusiveLower) {
-    throw new UnsupportedOperationException("This operation is not yet" +
-        "supported.");
+  public CompletableFuture<NavigableMap<String, V1>> subMap(
+      String upperKey, String lowerKey, boolean inclusiveUpper, boolean inclusiveLower) {
+    throw new UnsupportedOperationException("This operation is not yet supported.");
   }
 
   @Override
@@ -181,8 +163,8 @@ public CompletableFuture<Integer> size() {
   }
 
   @Override
-  public CompletableFuture<Boolean> containsKey(K1 key) {
-    return backingMap.containsKey(keyEncoder.apply(key));
+  public CompletableFuture<Boolean> containsKey(String key) {
+    return backingMap.containsKey(key);
   }
 
   @Override
@@ -191,23 +173,23 @@ public CompletableFuture<Boolean> containsValue(V1 value) {
   }
 
   @Override
-  public CompletableFuture<Versioned<V1>> get(K1 key) {
-    return backingMap.get(keyEncoder.apply(key)).thenApply(versionedValueTransform);
+  public CompletableFuture<Versioned<V1>> get(String key) {
+    return backingMap.get(key).thenApply(versionedValueTransform);
   }
 
   @Override
-  public CompletableFuture<Versioned<V1>> getOrDefault(K1 key, V1 defaultValue) {
-    return backingMap.getOrDefault(keyEncoder.apply(key), valueEncoder.apply(defaultValue)).thenApply(versionedValueTransform);
+  public CompletableFuture<Versioned<V1>> getOrDefault(String key, V1 defaultValue) {
+    return backingMap.getOrDefault(key, valueEncoder.apply(defaultValue)).thenApply(versionedValueTransform);
   }
 
   @Override
   public CompletableFuture<Versioned<V1>> computeIf(
-      K1 key,
+      String key,
       Predicate<? super V1> condition,
-      BiFunction<? super K1, ? super V1, ? extends V1> remappingFunction) {
+      BiFunction<? super String, ? super V1, ? extends V1> remappingFunction) {
     try {
       return backingMap.computeIf(
-          keyEncoder.apply(key),
+          key,
           v -> condition.test(valueDecoder.apply(v)),
           (k, v) -> valueEncoder.apply(remappingFunction.apply(key, valueDecoder.apply(v))))
           .thenApply(versionedValueTransform);
@@ -217,20 +199,20 @@ public CompletableFuture<Versioned<V1>> computeIf(
   }
 
   @Override
-  public CompletableFuture<Versioned<V1>> put(K1 key, V1 value) {
-    return backingMap.put(keyEncoder.apply(key), valueEncoder.apply(value))
+  public CompletableFuture<Versioned<V1>> put(String key, V1 value) {
+    return backingMap.put(key, valueEncoder.apply(value))
         .thenApply(versionedValueTransform);
   }
 
   @Override
-  public CompletableFuture<Versioned<V1>> putAndGet(K1 key, V1 value) {
-    return backingMap.putAndGet(keyEncoder.apply(key), valueEncoder.apply(value))
+  public CompletableFuture<Versioned<V1>> putAndGet(String key, V1 value) {
+    return backingMap.putAndGet(key, valueEncoder.apply(value))
         .thenApply(versionedValueTransform);
   }
 
   @Override
-  public CompletableFuture<Versioned<V1>> remove(K1 key) {
-    return backingMap.remove(keyEncoder.apply(key)).thenApply(versionedValueTransform);
+  public CompletableFuture<Versioned<V1>> remove(String key) {
+    return backingMap.remove(key).thenApply(versionedValueTransform);
   }
 
   @Override
@@ -239,11 +221,8 @@ public CompletableFuture<Void> clear() {
   }
 
   @Override
-  public CompletableFuture<Set<K1>> keySet() {
-    return backingMap.keySet()
-        .thenApply(keys -> keys.stream()
-            .map(keyDecoder)
-            .collect(Collectors.toSet()));
+  public CompletableFuture<Set<String>> keySet() {
+    return backingMap.keySet();
   }
 
   @Override
@@ -255,58 +234,56 @@ public CompletableFuture<Collection<Versioned<V1>>> values() {
   }
 
   @Override
-  public CompletableFuture<Set<Map.Entry<K1, Versioned<V1>>>> entrySet() {
+  public CompletableFuture<Set<Map.Entry<String, Versioned<V1>>>> entrySet() {
     return backingMap.entrySet()
         .thenApply(entries -> entries.stream()
-            .map(entry -> Maps.immutableEntry(keyDecoder.apply(entry.getKey()), versionedValueTransform.apply(entry.getValue())))
+            .map(entry -> Maps.immutableEntry(entry.getKey(), versionedValueTransform.apply(entry.getValue())))
             .collect(Collectors.toSet()));
   }
 
   @Override
-  public CompletableFuture<Versioned<V1>> putIfAbsent(K1 key, V1 value) {
-    return backingMap.putIfAbsent(keyEncoder.apply(key), valueEncoder.apply(value))
+  public CompletableFuture<Versioned<V1>> putIfAbsent(String key, V1 value) {
+    return backingMap.putIfAbsent(key, valueEncoder.apply(value))
         .thenApply(versionedValueTransform);
   }
 
   @Override
-  public CompletableFuture<Boolean> remove(K1 key, V1 value) {
-    return backingMap.remove(keyEncoder.apply(key), valueEncoder.apply(value));
+  public CompletableFuture<Boolean> remove(String key, V1 value) {
+    return backingMap.remove(key, valueEncoder.apply(value));
   }
 
   @Override
-  public CompletableFuture<Boolean> remove(K1 key, long version) {
-    return backingMap.remove(keyEncoder.apply(key), version);
+  public CompletableFuture<Boolean> remove(String key, long version) {
+    return backingMap.remove(key, version);
   }
 
   @Override
-  public CompletableFuture<Versioned<V1>> replace(K1 key, V1 value) {
-    return backingMap.replace(keyEncoder.apply(key), valueEncoder.apply(value))
+  public CompletableFuture<Versioned<V1>> replace(String key, V1 value) {
+    return backingMap.replace(key, valueEncoder.apply(value))
         .thenApply(versionedValueTransform);
   }
 
   @Override
-  public CompletableFuture<Boolean> replace(K1 key, V1 oldValue,
-                                            V1 newValue) {
-    return backingMap.replace(keyEncoder.apply(key), valueEncoder.apply(oldValue),
+  public CompletableFuture<Boolean> replace(String key, V1 oldValue, V1 newValue) {
+    return backingMap.replace(key, valueEncoder.apply(oldValue),
         valueEncoder.apply(newValue));
   }
 
   @Override
-  public CompletableFuture<Boolean> replace(K1 key, long oldVersion,
-                                            V1 newValue) {
-    return backingMap.replace(keyEncoder.apply(key), oldVersion,
+  public CompletableFuture<Boolean> replace(String key, long oldVersion, V1 newValue) {
+    return backingMap.replace(key, oldVersion,
         valueEncoder.apply(newValue));
   }
 
   @Override
-  public CompletableFuture<Void> addListener(MapEventListener<K1, V1> listener, Executor executor) {
+  public CompletableFuture<Void> addListener(MapEventListener<String, V1> listener, Executor executor) {
     InternalBackingMapEventListener backingMapEventListener = listeners.computeIfAbsent(listener,
         k -> new InternalBackingMapEventListener(listener));
     return backingMap.addListener(backingMapEventListener, executor);
   }
 
   @Override
-  public CompletableFuture<Void> removeListener(MapEventListener<K1, V1> listener) {
+  public CompletableFuture<Void> removeListener(MapEventListener<String, V1> listener) {
     InternalBackingMapEventListener backingMapEventListener = listeners.remove(listener);
     if (backingMapEventListener == null) {
       return CompletableFuture.completedFuture(null);
@@ -321,12 +298,12 @@ public CompletableFuture<Version> begin(TransactionId transactionId) {
   }
 
   @Override
-  public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<K1, V1>> transactionLog) {
+  public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<String, V1>> transactionLog) {
     throw new UnsupportedOperationException("This operation is not yet supported.");
   }
 
   @Override
-  public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<K1, V1>> transactionLog) {
+  public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<String, V1>> transactionLog) {
     throw new UnsupportedOperationException("This operation is not yet supported.");
   }
 
@@ -345,19 +322,19 @@ public CompletableFuture<Void> close() {
     return backingMap.close();
   }
 
-  private class InternalBackingMapEventListener implements MapEventListener<K2, V2> {
-    private final MapEventListener<K1, V1> listener;
+  private class InternalBackingMapEventListener implements MapEventListener<String, V2> {
+    private final MapEventListener<String, V1> listener;
 
-    InternalBackingMapEventListener(MapEventListener<K1, V1> listener) {
+    InternalBackingMapEventListener(MapEventListener<String, V1> listener) {
       this.listener = listener;
     }
 
     @Override
-    public void event(MapEvent<K2, V2> event) {
+    public void event(MapEvent<String, V2> event) {
       listener.event(new MapEvent<>(
           event.type(),
           event.name(),
-          keyDecoder.apply(event.key()),
+          event.key(),
           event.newValue() != null ? event.newValue().map(valueDecoder) : null,
           event.oldValue() != null ? event.oldValue().map(valueDecoder) : null));
     }
diff --git a/core/src/test/java/io/atomix/map/impl/ConsistentTreeMapTest.java b/core/src/test/java/io/atomix/map/impl/ConsistentTreeMapTest.java
index 1111748fa7..72dccbe9bb 100644
--- a/core/src/test/java/io/atomix/map/impl/ConsistentTreeMapTest.java
+++ b/core/src/test/java/io/atomix/map/impl/ConsistentTreeMapTest.java
@@ -59,7 +59,7 @@ public void testBasicMapOperations() throws Throwable {
     //make sure that the previous section has been cleaned up, they serve
     //the secondary purpose of testing isEmpty but that is not their
     //primary purpose.
-    AsyncConsistentTreeMap<String, String> map = createResource("basicTestMap");
+    AsyncConsistentTreeMap<String> map = createResource("basicTestMap");
     //test size
     map.size().thenAccept(result -> assertEquals(0, (int) result)).join();
     map.isEmpty().thenAccept(result -> assertTrue(result)).join();
@@ -243,7 +243,7 @@ public void mapListenerTests() throws Throwable {
     final String value2 = "value2";
     final String value3 = "value3";
 
-    AsyncConsistentTreeMap<String, String> map = createResource("treeMapListenerTestMap");
+    AsyncConsistentTreeMap<String> map = createResource("treeMapListenerTestMap");
     TestMapEventListener listener = new TestMapEventListener();
 
     // add listener; insert new value into map and verify an INSERT event
@@ -306,7 +306,7 @@ public void mapListenerTests() throws Throwable {
 
   @Test
   public void treeMapFunctionsTest() {
-    AsyncConsistentTreeMap<String, String> map = createResource("treeMapFunctionTestMap");
+    AsyncConsistentTreeMap<String> map = createResource("treeMapFunctionTestMap");
     //Tests on empty map
     map.firstKey().thenAccept(result -> assertNull(result)).join();
     map.lastKey().thenAccept(result -> assertNull(result)).join();
@@ -454,9 +454,9 @@ public void treeMapFunctionsTest() {
     //map.delete().join();
   }
 
-  private AsyncConsistentTreeMap<String, String> createResource(String mapName) {
+  private AsyncConsistentTreeMap<String> createResource(String mapName) {
     try {
-      return atomix().<String, String>consistentTreeMapBuilder(mapName).buildAsync();
+      return atomix().<String>consistentTreeMapBuilder(mapName).buildAsync();
     } catch (Throwable e) {
       throw new RuntimeException(e.toString());
     }