diff --git a/src/radix.h b/src/radix.h
--- a/src/radix.h
+++ b/src/radix.h
@@ -33,7 +33,7 @@
  * to speed before destroying anything. It is therefore crucial that the lock be
  * taken before reading anything in the tree.
  */
-template <typename T> struct RadixTree {
+template <typename T> struct Uint256RadixKey {
 private:
     static const int BITS = 4;
     static const int MASK = (1 << BITS) - 1;
@@ -50,13 +50,13 @@
     std::atomic<RadixElement> root;
 
 public:
-    RadixTree() : root(RadixElement()) {}
-    ~RadixTree() { root.load().decrementRefCount(); }
+    Uint256RadixKey() : root(RadixElement()) {}
+    ~Uint256RadixKey() { root.load().decrementRefCount(); }
 
     /**
      * Copy semantic.
      */
-    RadixTree(const RadixTree &src) : RadixTree() {
+    Uint256RadixKey(const Uint256RadixKey &src) : Uint256RadixKey() {
         {
             RCULock lock;
             RadixElement e = src.root.load();
@@ -69,7 +69,7 @@
         RCULock::synchronize();
     }
 
-    RadixTree &operator=(const RadixTree &rhs) {
+    Uint256RadixKey &operator=(const Uint256RadixKey &rhs) {
         {
             RCULock lock;
             RadixElement e = rhs.root.load();
@@ -88,8 +88,10 @@
     /**
      * Move semantic.
      */
-    RadixTree(RadixTree &&src) : RadixTree() { *this = std::move(src); }
-    RadixTree &operator=(RadixTree &&rhs) {
+    Uint256RadixKey(Uint256RadixKey &&src) : Uint256RadixKey() {
+        *this = std::move(src);
+    }
+    Uint256RadixKey &operator=(Uint256RadixKey &&rhs) {
         {
             RCULock lock;
             RadixElement e = rhs.root.load();
@@ -134,7 +136,7 @@
     }
 
     RCUPtr<const T> get(const KeyType &key) const {
-        T const *ptr = const_cast<RadixTree *>(this)->get(key).release();
+        T const *ptr = const_cast<Uint256RadixKey *>(this)->get(key).release();
         return RCUPtr<const T>::acquire(ptr);
     }
 
diff --git a/src/test/radix_tests.cpp b/src/test/radix_tests.cpp
--- a/src/test/radix_tests.cpp
+++ b/src/test/radix_tests.cpp
@@ -63,7 +63,7 @@
 };
 
 template <typename E> void testInsert() {
-    RadixTree<E> mytree;
+    Uint256RadixKey<E> mytree;
 
     auto zero = RCUPtr<E>::make(0);
     auto one = RCUPtr<E>::make(1);
@@ -119,7 +119,7 @@
 }
 
 template <typename E> void testGet() {
-    RadixTree<E> mytree;
+    Uint256RadixKey<E> mytree;
 
     auto zero = RCUPtr<E>::make(0);
     auto one = RCUPtr<E>::make(1);
@@ -193,7 +193,7 @@
 }
 
 template <typename E> void testRemove() {
-    RadixTree<E> mytree;
+    Uint256RadixKey<E> mytree;
 
     auto zero = RCUPtr<E>::make(0);
     auto one = RCUPtr<E>::make(1);
@@ -282,7 +282,7 @@
 
 BOOST_AUTO_TEST_CASE(const_element_test) {
     using C = const TestElementInt<uint64_t>;
-    RadixTree<C> mytree;
+    Uint256RadixKey<C> mytree;
 
     BOOST_CHECK(mytree.insert(RCUPtr<C>::make(0)));
     BOOST_CHECK(mytree.insert(RCUPtr<C>::make(1)));
@@ -315,7 +315,7 @@
     BOOST_CHECK(!mytree.remove(3));
 }
 
-void CheckConstTree(const RadixTree<TestElementInt<uint64_t>> &mytree,
+void CheckConstTree(const Uint256RadixKey<TestElementInt<uint64_t>> &mytree,
                     bool expected) {
     BOOST_CHECK_EQUAL(!!mytree.get(0), expected);
     BOOST_CHECK_EQUAL(!!mytree.get(1), expected);
@@ -325,7 +325,7 @@
 
 BOOST_AUTO_TEST_CASE(const_tree_test) {
     using E = TestElementInt<uint64_t>;
-    RadixTree<E> mytree;
+    Uint256RadixKey<E> mytree;
 
     CheckConstTree(mytree, false);
 
@@ -347,14 +347,14 @@
 BOOST_AUTO_TEST_CASE(test_cow) {
     using E = TestElementInt<uint32_t>;
 
-    RadixTree<E> mytree;
+    Uint256RadixKey<E> mytree;
 
     BOOST_CHECK(mytree.insert(RCUPtr<E>::make(0)));
     BOOST_CHECK(mytree.insert(RCUPtr<E>::make(1)));
     BOOST_CHECK(mytree.insert(RCUPtr<E>::make(2)));
     BOOST_CHECK(mytree.insert(RCUPtr<E>::make(3)));
 
-    RadixTree<E> copyTree = mytree;
+    Uint256RadixKey<E> copyTree = mytree;
 
     // The copy tree is identical.
     BOOST_CHECK(copyTree.get(0));
@@ -398,14 +398,14 @@
 BOOST_AUTO_TEST_CASE(test_move) {
     using E = TestElementInt<uint32_t>;
 
-    RadixTree<E> mytree;
+    Uint256RadixKey<E> mytree;
 
     BOOST_CHECK(mytree.insert(RCUPtr<E>::make(0)));
     BOOST_CHECK(mytree.insert(RCUPtr<E>::make(1)));
     BOOST_CHECK(mytree.insert(RCUPtr<E>::make(2)));
     BOOST_CHECK(mytree.insert(RCUPtr<E>::make(3)));
 
-    RadixTree<E> movedTree = std::move(mytree);
+    Uint256RadixKey<E> movedTree = std::move(mytree);
 
     BOOST_CHECK(!mytree.remove(0));
     BOOST_CHECK(!mytree.remove(1));
@@ -424,7 +424,7 @@
 BOOST_AUTO_TEST_CASE(insert_stress_test) {
     using E = TestElementInt<uint32_t>;
 
-    RadixTree<E> mytree;
+    Uint256RadixKey<E> mytree;
     std::atomic<uint32_t> success{0};
     std::vector<std::thread> threads;
 
@@ -482,7 +482,7 @@
 BOOST_AUTO_TEST_CASE(tree_traversal) {
     using E = TestElement<uint32_t>;
 
-    RadixTree<E> mytree;
+    Uint256RadixKey<E> mytree;
 
     // Build a vector of elements in ascending key order
     std::vector<RCUPtr<E>> elements;