diff --git a/src/ripple/types/api/RippleAssets.h b/src/ripple/types/api/RippleAssets.h
index ee1051158..82799675e 100644
--- a/src/ripple/types/api/RippleAssets.h
+++ b/src/ripple/types/api/RippleAssets.h
@@ -180,8 +180,8 @@ bool operator<= (RippleAssetType <LhsByValue> const& lhs,
 
 //------------------------------------------------------------------------------
 
-typedef RippleAssetType <false> RippleAssetRef;
 typedef RippleAssetType <true> RippleAsset;
+typedef RippleAssetType <false> RippleAssetRef;
 
 /** Create an asset specifier by parsing the given JSON.
     Errors, if any, will be returned or injected into the specified result
@@ -285,7 +285,7 @@ bool operator< (RippleBookType <LhsByValue> const& lhs,
     RippleBookType <RhsByValue> const& rhs)
 {
     int const diff (compare (lhs.in, rhs.in));
-    if (diff != 0 || lhs.in.is_xrp ())
+    if (diff != 0)
         return diff < 0;
     return lhs.out < rhs.out;
 }
@@ -314,8 +314,8 @@ bool operator<= (RippleBookType <LhsByValue> const& lhs,
 
 //------------------------------------------------------------------------------
 
-typedef RippleBookType <false> RippleBook;
-typedef RippleBookType <true> RippleBookRef;
+typedef RippleBookType <true> RippleBook;
+typedef RippleBookType <false> RippleBookRef;
 
 }
 
diff --git a/src/ripple/types/impl/RippleAssets.cpp b/src/ripple/types/impl/RippleAssets.cpp
index dc8507ad5..1f048df65 100644
--- a/src/ripple/types/impl/RippleAssets.cpp
+++ b/src/ripple/types/impl/RippleAssets.cpp
@@ -18,6 +18,7 @@
 //==============================================================================
 
 #include <set>
+#include <typeinfo>
 #include <unordered_set>
 #include <boost/unordered_set.hpp>
 
@@ -32,6 +33,81 @@ namespace ripple {
 class RippleAssetTests : public UnitTest
 {
 public:
+    // Comparison, hash tests for uint60 (via base_uint)
+    template <typename Unsigned>
+    void testUnsigned ()
+    {
+        Unsigned const u1 (1);
+        Unsigned const u2 (2);
+        Unsigned const u3 (3);
+
+        expect (u1 != u2);
+        expect (u1 <  u2);
+        expect (u1 <= u2);
+        expect (u2 <= u2);
+        expect (u2 == u2);
+        expect (u2 >= u2);
+        expect (u3 >= u2);
+        expect (u3 >  u2);
+
+        std::hash <Unsigned> const hash;
+
+        expect (hash (u1) == hash (u1));
+        expect (hash (u2) == hash (u2));
+        expect (hash (u3) == hash (u3));
+        expect (hash (u1) != hash (u2));
+        expect (hash (u1) != hash (u3));
+        expect (hash (u2) != hash (u3));
+    }
+
+    //--------------------------------------------------------------------------
+
+    // Comparison, hash tests for RippleAssetType
+    template <class Asset>
+    void testAssetType ()
+    {
+        RippleCurrency const c1 (1); RippleIssuer const i1 (1);
+        RippleCurrency const c2 (2); RippleIssuer const i2 (2);
+        RippleCurrency const c3 (3); RippleIssuer const i3 (3);
+
+        expect (Asset (c1, i1) != Asset (c2, i1));
+        expect (Asset (c1, i1) <  Asset (c2, i1));
+        expect (Asset (c1, i1) <= Asset (c2, i1));
+        expect (Asset (c2, i1) <= Asset (c2, i1));
+        expect (Asset (c2, i1) == Asset (c2, i1));
+        expect (Asset (c2, i1) >= Asset (c2, i1));
+        expect (Asset (c3, i1) >= Asset (c2, i1));
+        expect (Asset (c3, i1) >  Asset (c2, i1));
+        expect (Asset (c1, i1) != Asset (c1, i2));
+        expect (Asset (c1, i1) <  Asset (c1, i2));
+        expect (Asset (c1, i1) <= Asset (c1, i2));
+        expect (Asset (c1, i2) <= Asset (c1, i2));
+        expect (Asset (c1, i2) == Asset (c1, i2));
+        expect (Asset (c1, i2) >= Asset (c1, i2));
+        expect (Asset (c1, i3) >= Asset (c1, i2));
+        expect (Asset (c1, i3) >  Asset (c1, i2));
+
+        std::hash <Asset> const hash;
+
+        expect (hash (Asset (c1, i1)) == hash (Asset (c1, i1)));
+        expect (hash (Asset (c1, i2)) == hash (Asset (c1, i2)));
+        expect (hash (Asset (c1, i3)) == hash (Asset (c1, i3)));
+        expect (hash (Asset (c2, i1)) == hash (Asset (c2, i1)));
+        expect (hash (Asset (c2, i2)) == hash (Asset (c2, i2)));
+        expect (hash (Asset (c2, i3)) == hash (Asset (c2, i3)));
+        expect (hash (Asset (c3, i1)) == hash (Asset (c3, i1)));
+        expect (hash (Asset (c3, i2)) == hash (Asset (c3, i2)));
+        expect (hash (Asset (c3, i3)) == hash (Asset (c3, i3)));
+        expect (hash (Asset (c1, i1)) != hash (Asset (c1, i2)));
+        expect (hash (Asset (c1, i1)) != hash (Asset (c1, i3)));
+        expect (hash (Asset (c1, i1)) != hash (Asset (c2, i1)));
+        expect (hash (Asset (c1, i1)) != hash (Asset (c2, i2)));
+        expect (hash (Asset (c1, i1)) != hash (Asset (c2, i3)));
+        expect (hash (Asset (c1, i1)) != hash (Asset (c3, i1)));
+        expect (hash (Asset (c1, i1)) != hash (Asset (c3, i2)));
+        expect (hash (Asset (c1, i1)) != hash (Asset (c3, i3)));
+    }
+
     template <class Set>
     void testAssetSet ()
     {
@@ -42,27 +118,40 @@ public:
         RippleAssetRef const a1 (c1, i1);
         RippleAssetRef const a2 (c2, i2);
 
-        Set c;
+        {
+            Set c;
 
-        c.insert (a1);
-        c.insert (a2);
-        expect (c.erase (RippleAsset (c1, i2)) == 0);
-        expect (c.erase (RippleAsset (c1, i1)) == 1);
-        expect (c.erase (RippleAsset (c2, i2)) == 1);
-        expect (c.empty ());
+            c.insert (a1);
+            if (! expect (c.size () == 1)) return;
+            c.insert (a2);
+            if (! expect (c.size () == 2)) return;
 
-        c.insert (a1);
-        c.insert (a2);
-        expect (c.erase (RippleAssetRef (c1, i2)) == 0);
-        expect (c.erase (RippleAssetRef (c1, i1)) == 1);
-        expect (c.erase (RippleAssetRef (c2, i2)) == 1);
-        expect (c.empty ());
+            if (! expect (c.erase (RippleAsset (c1, i2)) == 0)) return;
+            if (! expect (c.erase (RippleAsset (c1, i1)) == 1)) return;
+            if (! expect (c.erase (RippleAsset (c2, i2)) == 1)) return;
+            if (! expect (c.empty ())) return;
+        }
 
-#if STL_SET_HAS_EMPLACE
-        c.emplace (c1, i1);
-        c.emplace (c2, i2);
-        expect (c.size() == 2);
-#endif
+        {
+            Set c;
+
+            c.insert (a1);
+            if (! expect (c.size () == 1)) return;
+            c.insert (a2);
+            if (! expect (c.size () == 2)) return;
+
+            if (! expect (c.erase (RippleAssetRef (c1, i2)) == 0)) return;
+            if (! expect (c.erase (RippleAssetRef (c1, i1)) == 1)) return;
+            if (! expect (c.erase (RippleAssetRef (c2, i2)) == 1)) return;
+            if (! expect (c.empty ())) return;
+
+    #if STL_SET_HAS_EMPLACE
+            c.emplace (c1, i1);
+            if (! expect (c.size() == 1)) return;
+            c.emplace (c2, i2);
+            if (! expect (c.size() == 2)) return;
+    #endif
+        }
     }
 
     template <class Map>
@@ -75,74 +164,119 @@ public:
         RippleAssetRef const a1 (c1, i1);
         RippleAssetRef const a2 (c2, i2);
 
-        Map c;
+        {
+            Map c;
 
-        c.insert (std::make_pair (a1, 1));
-        c.insert (std::make_pair (a2, 2));
-        expect (c.erase (RippleAsset (c1, i2)) == 0);
-        expect (c.erase (RippleAsset (c1, i1)) == 1);
-        expect (c.erase (RippleAsset (c2, i2)) == 1);
-        expect (c.empty ());
+            c.insert (std::make_pair (a1, 1));
+            if (! expect (c.size () == 1)) return;
+            c.insert (std::make_pair (a2, 2));
+            if (! expect (c.size () == 2)) return;
 
-        c.insert (std::make_pair (a1, 1));
-        c.insert (std::make_pair (a2, 2));
-        expect (c.erase (RippleAssetRef (c1, i2)) == 0);
-        expect (c.erase (RippleAssetRef (c1, i1)) == 1);
-        expect (c.erase (RippleAssetRef (c2, i2)) == 1);
-        expect (c.empty ());
+            if (! expect (c.erase (RippleAsset (c1, i2)) == 0)) return;
+            if (! expect (c.erase (RippleAsset (c1, i1)) == 1)) return;
+            if (! expect (c.erase (RippleAsset (c2, i2)) == 1)) return;
+            if (! expect (c.empty ())) return;
+        }
+
+        {
+            Map c;
+        
+            c.insert (std::make_pair (a1, 1));
+            if (! expect (c.size () == 1)) return;
+            c.insert (std::make_pair (a2, 2));
+            if (! expect (c.size () == 2)) return;
+
+            if (! expect (c.erase (RippleAssetRef (c1, i2)) == 0)) return;
+            if (! expect (c.erase (RippleAssetRef (c1, i1)) == 1)) return;
+            if (! expect (c.erase (RippleAssetRef (c2, i2)) == 1)) return;
+            if (! expect (c.empty ())) return;
+        }
     }
 
-    void testAssets ()
+    void testAssetSets ()
     {
-        beginTestCase ("assets");
-
-        RippleCurrency const c1 (1);
-        RippleIssuer   const i1 (1);
-        RippleCurrency const c2 (2);
-        RippleIssuer   const i2 (2);
-
-        {
-            RippleAssetRef a0 (xrp_asset ());
-            expect (a0 == xrp_asset());
-
-            RippleAssetRef a1 (c1, i1);
-            RippleAssetRef a2 (a1);
-
-            expect (a1 == a2);
-        }
-
-        {
-            // VFALCO NOTE this should be uninitialized
-            RippleAsset uninitialized_asset;
-        }
-
-        {
-            RippleAsset a1 (c1, i1);
-            RippleAsset a2 (a1);
-
-            expect (a1 == a2);
-            expect (a1 != xrp_asset());
-
-            a2 = RippleAsset (c2, i2);
-
-            expect (a1 < a2);
-        }
-
+        beginTestCase ("std::set <RippleAsset>");
         testAssetSet <std::set <RippleAsset>> ();
-        testAssetSet <std::set <RippleAssetRef>> ();
-        testAssetSet <std::unordered_set <RippleAsset>> ();
-        testAssetSet <std::unordered_set <RippleAssetRef>> ();
-        testAssetSet <boost::unordered_set <RippleAsset>> ();
-        testAssetSet <boost::unordered_set <RippleAssetRef>> ();
 
+        beginTestCase ("std::set <RippleAssetRef>");
+        testAssetSet <std::set <RippleAssetRef>> ();
+
+        beginTestCase ("std::unordered_set <RippleAsset>");
+        testAssetSet <std::unordered_set <RippleAsset>> ();
+
+        beginTestCase ("std::unordered_set <RippleAssetRef>");
+        testAssetSet <std::unordered_set <RippleAssetRef>> ();
+
+        beginTestCase ("boost::unordered_set <RippleAsset>");
+        testAssetSet <boost::unordered_set <RippleAsset>> ();
+
+        beginTestCase ("boost::unordered_set <RippleAssetRef>");
+        testAssetSet <boost::unordered_set <RippleAssetRef>> ();
+    }
+
+    void testAssetMaps ()
+    {
+            beginTestCase ("std::map <RippleAsset, int>");
         testAssetMap <std::map <RippleAsset, int>> ();
+
+        beginTestCase ("std::map <RippleAssetRef, int>");
         testAssetMap <std::map <RippleAssetRef, int>> ();
+
+        beginTestCase ("std::unordered_map <RippleAsset, int>");
         testAssetMap <std::unordered_map <RippleAsset, int>> ();
+
+        beginTestCase ("std::unordered_map <RippleAssetRef, int>");
         testAssetMap <std::unordered_map <RippleAssetRef, int>> ();
+
+        beginTestCase ("boost::unordered_map <RippleAsset, int>");
         testAssetMap <boost::unordered_map <RippleAsset, int>> ();
+
+        beginTestCase ("boost::unordered_map <RippleAssetRef, int>");
         testAssetMap <boost::unordered_map <RippleAssetRef, int>> ();
     }
 
+    //--------------------------------------------------------------------------
+
+    // Comparison, hash tests for RippleBookType
+    template <class Book>
+    void testBook ()
+    {
+        RippleCurrency const c1 (1); RippleIssuer const i1 (1);
+        RippleCurrency const c2 (2); RippleIssuer const i2 (2);
+        RippleCurrency const c3 (3); RippleIssuer const i3 (3);
+
+        RippleAsset a1 (c1, i1);
+        RippleAsset a2 (c1, i2);
+        RippleAsset a3 (c2, i2);
+        RippleAsset a4 (c3, i2);
+
+        expect (Book (a1, a2) != Book (a2, a3));
+        expect (Book (a1, a2) <  Book (a2, a3));
+        expect (Book (a1, a2) <= Book (a2, a3));
+        expect (Book (a2, a3) <= Book (a2, a3));
+        expect (Book (a2, a3) == Book (a2, a3));
+        expect (Book (a2, a3) >= Book (a2, a3));
+        expect (Book (a3, a4) >= Book (a2, a3));
+        expect (Book (a3, a4) >  Book (a2, a3));
+
+        std::hash <Book> const hash;
+
+        expect (hash (Book (a1, a2)) == hash (Book (a1, a2)));
+        expect (hash (Book (a1, a3)) == hash (Book (a1, a3)));
+        expect (hash (Book (a1, a4)) == hash (Book (a1, a4)));
+        expect (hash (Book (a2, a3)) == hash (Book (a2, a3)));
+        expect (hash (Book (a2, a4)) == hash (Book (a2, a4)));
+        expect (hash (Book (a3, a4)) == hash (Book (a3, a4)));
+
+        expect (hash (Book (a1, a2)) != hash (Book (a1, a3)));
+        expect (hash (Book (a1, a2)) != hash (Book (a1, a4)));
+        expect (hash (Book (a1, a2)) != hash (Book (a2, a3)));
+        expect (hash (Book (a1, a2)) != hash (Book (a2, a4)));
+        expect (hash (Book (a1, a2)) != hash (Book (a3, a4)));
+    }
+
+    //--------------------------------------------------------------------------
+
     template <class Set>
     void testBookSet ()
     {
@@ -155,27 +289,40 @@ public:
         RippleBookRef  const b1 (a1, a2);
         RippleBookRef  const b2 (a2, a1);
 
-        Set c;
+        {
+            Set c;
 
-        c.insert (b1);
-        c.insert (b2);
-        expect (c.erase (RippleBook (a1, a1)) == 0);
-        expect (c.erase (RippleBook (a1, a2)) == 1);
-        expect (c.erase (RippleBook (a2, a1)) == 1);
-        expect (c.empty ());
+            c.insert (b1);
+            if (! expect (c.size () == 1)) return;
+            c.insert (b2);
+            if (! expect (c.size () == 2)) return;
 
-        c.insert (b1);
-        c.insert (b2);
-        expect (c.erase (RippleBookRef (a1, a1)) == 0);
-        expect (c.erase (RippleBookRef (a1, a2)) == 1);
-        expect (c.erase (RippleBookRef (a2, a1)) == 1);
-        expect (c.empty ());
+            if (! expect (c.erase (RippleBook (a1, a1)) == 0)) return;
+            if (! expect (c.erase (RippleBook (a1, a2)) == 1)) return;
+            if (! expect (c.erase (RippleBook (a2, a1)) == 1)) return;
+            if (! expect (c.empty ())) return;
+        }
 
-#if STL_SET_HAS_EMPLACE
-        c.emplace (a1, a2);
-        c.emplace (a2, a1);
-        expect (c.size() == 2);
-#endif
+        {
+            Set c;
+
+            c.insert (b1);
+            if (! expect (c.size () == 1)) return;
+            c.insert (b2);
+            if (! expect (c.size () == 2)) return;
+
+            if (! expect (c.erase (RippleBookRef (a1, a1)) == 0)) return;
+            if (! expect (c.erase (RippleBookRef (a1, a2)) == 1)) return;
+            if (! expect (c.erase (RippleBookRef (a2, a1)) == 1)) return;
+            if (! expect (c.empty ())) return;
+
+    #if STL_SET_HAS_EMPLACE
+            c.emplace (a1, a2);
+            if (! expect (c.size() == 1)) return;
+            c.emplace (a2, a1);
+            if (! expect (c.size() == 2)) return;
+    #endif
+        }
     }
 
     template <class Map>
@@ -190,55 +337,115 @@ public:
         RippleBookRef  const b1 (a1, a2);
         RippleBookRef  const b2 (a2, a1);
 
-        Map c;
+        //typename Map::value_type value_type;
+        //std::pair <RippleBookRef const, int> value_type;
 
-        c.insert (std::make_pair (b1, 1));
-        c.insert (std::make_pair (b2, 2));
-        expect (c.erase (RippleBook (a1, a1)) == 0);
-        expect (c.erase (RippleBook (a1, a2)) == 1);
-        expect (c.erase (RippleBook (a2, a1)) == 1);
-        expect (c.empty ());
+        {
+            Map c;
 
-        c.insert (std::make_pair (b1, 1));
-        c.insert (std::make_pair (b2, 2));
-        expect (c.erase (RippleBookRef (a1, a1)) == 0);
-        expect (c.erase (RippleBookRef (a1, a2)) == 1);
-        expect (c.erase (RippleBookRef (a2, a1)) == 1);
-        expect (c.empty ());
+            //c.insert (value_type (b1, 1));
+            c.insert (std::make_pair (b1, 1));
+            if (! expect (c.size () == 1)) return;
+            //c.insert (value_type (b2, 2));
+            c.insert (std::make_pair (b2, 1));
+            if (! expect (c.size () == 2)) return;
+
+            if (! expect (c.erase (RippleBook (a1, a1)) == 0)) return;
+            if (! expect (c.erase (RippleBook (a1, a2)) == 1)) return;
+            if (! expect (c.erase (RippleBook (a2, a1)) == 1)) return;
+            if (! expect (c.empty ())) return;
+        }
+
+        {
+            Map c;
+
+            //c.insert (value_type (b1, 1));
+            c.insert (std::make_pair (b1, 1));
+            if (! expect (c.size () == 1)) return;
+            //c.insert (value_type (b2, 2));
+            c.insert (std::make_pair (b2, 1));
+            if (! expect (c.size () == 2)) return;
+
+            if (! expect (c.erase (RippleBookRef (a1, a1)) == 0)) return;
+            if (! expect (c.erase (RippleBookRef (a1, a2)) == 1)) return;
+            if (! expect (c.erase (RippleBookRef (a2, a1)) == 1)) return;
+            if (! expect (c.empty ())) return;
+        }
     }
 
-    void testBooks ()
+    void testBookSets ()
     {
-        beginTestCase ("books");
-
-        RippleAsset a1 (RippleCurrency (1), RippleIssuer (1));
-        RippleAsset a2 (RippleCurrency (2), RippleIssuer (2));
-
-        RippleBook b1 (a1, a2);
-        RippleBook b2 (a2, a1);
-
-        expect (b1 != b2);
-        expect (b1 < b2);
-
+        beginTestCase ("std::set <RippleBook>");
         testBookSet <std::set <RippleBook>> ();
-        testBookSet <std::set <RippleBookRef>> ();
-        testBookSet <std::unordered_set <RippleBook>> ();
-        testBookSet <std::unordered_set <RippleBookRef>> ();
-        testBookSet <boost::unordered_set <RippleBook>> ();
-        testBookSet <boost::unordered_set <RippleBookRef>> ();
 
+        beginTestCase ("std::set <RippleBookRef>");
+        testBookSet <std::set <RippleBookRef>> ();
+
+        beginTestCase ("std::unordered_set <RippleBook>");
+        testBookSet <std::unordered_set <RippleBook>> ();
+
+        beginTestCase ("std::unordered_set <RippleBookRef>");
+        testBookSet <std::unordered_set <RippleBookRef>> ();
+
+        beginTestCase ("boost::unordered_set <RippleBook>");
+        testBookSet <boost::unordered_set <RippleBook>> ();
+
+        beginTestCase ("boost::unordered_set <RippleBookRef>");
+        testBookSet <boost::unordered_set <RippleBookRef>> ();
+    }
+
+    void testBookMaps ()
+    {
+        beginTestCase ("std::map <RippleBook, int>");
         testBookMap <std::map <RippleBook, int>> ();
+
+        beginTestCase ("std::map <RippleBookRef, int>");
         testBookMap <std::map <RippleBookRef, int>> ();
+
+        beginTestCase ("std::unordered_map <RippleBook, int>");
         testBookMap <std::unordered_map <RippleBook, int>> ();
+
+        beginTestCase ("std::unordered_map <RippleBookRef, int>");
         testBookMap <std::unordered_map <RippleBookRef, int>> ();
+
+        beginTestCase ("boost::unordered_map <RippleBook, int>");
         testBookMap <boost::unordered_map <RippleBook, int>> ();
+
+        beginTestCase ("boost::unordered_map <RippleBookRef, int>");
         testBookMap <boost::unordered_map <RippleBookRef, int>> ();
     }
 
+    //--------------------------------------------------------------------------
+
     void runTest ()
     {
-        testAssets ();
-        testBooks ();
+        beginTestCase ("RippleCurrency");
+        testUnsigned <RippleCurrency> ();
+
+        beginTestCase ("RippleIssuer");
+        testUnsigned <RippleIssuer> ();
+
+        // ---
+
+        beginTestCase ("RippleAsset");
+        testAssetType <RippleAsset> ();
+
+        beginTestCase ("RippleAssetRef");
+        testAssetType <RippleAssetRef> ();
+
+        testAssetSets ();
+        testAssetMaps ();
+
+        // ---
+
+        beginTestCase ("RippleBook");
+        testBook <RippleBook> ();
+
+        beginTestCase ("RippleBookRef");
+        testBook <RippleBookRef> ();
+
+        testBookSets ();
+        testBookMaps ();
     }
 
     RippleAssetTests () : UnitTest ("RippleAsset", "ripple")