Merge pull request #4988

973403bc Adding initial support for broadcasting transactions over Tor (Lee Clagett)

4 files changed, 936 insertions, 8 deletions

diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt
index 5f7fa84a5..cb421c847 100644
--- a/tests/unit_tests/CMakeLists.txt
+++ b/tests/unit_tests/CMakeLists.txt
@@ -62,6 +62,7 @@ set(unit_tests_sources
   mul_div.cpp
   multiexp.cpp
   multisig.cpp
+  net.cpp
   notify.cpp
   output_distribution.cpp
   parse_amount.cpp
@@ -100,6 +101,7 @@ target_link_libraries(unit_tests
     cryptonote_core
     blockchain_db
     rpc
+    net
     serialization
     wallet
     p2p
diff --git a/tests/unit_tests/epee_utils.cpp b/tests/unit_tests/epee_utils.cpp
index 3d5882d7d..18fb262c2 100644
--- a/tests/unit_tests/epee_utils.cpp
+++ b/tests/unit_tests/epee_utils.cpp
@@ -545,6 +545,8 @@ TEST(StringTools, GetIpInt32)
 
 TEST(NetUtils, IPv4NetworkAddress)
 {
+  static_assert(epee::net_utils::ipv4_network_address::get_type_id() == epee::net_utils::address_type::ipv4, "bad ipv4 type id");
+
   const auto ip1 = boost::endian::native_to_big(0x330012FFu);
   const auto ip_loopback = boost::endian::native_to_big(0x7F000001u);
   const auto ip_local = boost::endian::native_to_big(0x0A000000u);
@@ -555,7 +557,7 @@ TEST(NetUtils, IPv4NetworkAddress)
   EXPECT_STREQ("51.0.18.255", address1.host_str().c_str());
   EXPECT_FALSE(address1.is_loopback());
   EXPECT_FALSE(address1.is_local());
-  EXPECT_EQ(epee::net_utils::ipv4_network_address::ID, address1.get_type_id());
+  EXPECT_EQ(epee::net_utils::ipv4_network_address::get_type_id(), address1.get_type_id());
   EXPECT_EQ(ip1, address1.ip());
   EXPECT_EQ(65535, address1.port());
   EXPECT_TRUE(epee::net_utils::ipv4_network_address{std::move(address1)} == address1);
@@ -568,7 +570,7 @@ TEST(NetUtils, IPv4NetworkAddress)
   EXPECT_STREQ("127.0.0.1", loopback.host_str().c_str());
   EXPECT_TRUE(loopback.is_loopback());
   EXPECT_FALSE(loopback.is_local());
-  EXPECT_EQ(epee::net_utils::ipv4_network_address::ID, address1.get_type_id());
+  EXPECT_EQ(epee::net_utils::ipv4_network_address::get_type_id(), address1.get_type_id());
   EXPECT_EQ(ip_loopback, loopback.ip());
   EXPECT_EQ(0, loopback.port());
 
@@ -624,7 +626,9 @@ TEST(NetUtils, NetworkAddress)
     constexpr static bool is_local() noexcept { return false; }
     static std::string str() { return {}; }
     static std::string host_str() { return {}; }
-    constexpr static uint8_t get_type_id() noexcept { return uint8_t(-1); }
+    constexpr static epee::net_utils::address_type get_type_id() noexcept { return epee::net_utils::address_type(-1); }
+    constexpr static epee::net_utils::zone get_zone() noexcept { return epee::net_utils::zone::invalid; }
+    constexpr static bool is_blockable() noexcept { return false; }
   };
 
   const epee::net_utils::network_address empty;
@@ -634,7 +638,9 @@ TEST(NetUtils, NetworkAddress)
   EXPECT_STREQ("<none>", empty.host_str().c_str());
   EXPECT_FALSE(empty.is_loopback());
   EXPECT_FALSE(empty.is_local());
-  EXPECT_EQ(0, empty.get_type_id());
+  EXPECT_EQ(epee::net_utils::address_type::invalid, empty.get_type_id());
+  EXPECT_EQ(epee::net_utils::zone::invalid, empty.get_zone());
+  EXPECT_FALSE(empty.is_blockable());
   EXPECT_THROW(empty.as<custom_address>(), std::bad_cast);
 
   epee::net_utils::network_address address1{
@@ -650,7 +656,9 @@ TEST(NetUtils, NetworkAddress)
   EXPECT_STREQ("51.0.18.255", address1.host_str().c_str());
   EXPECT_FALSE(address1.is_loopback());
   EXPECT_FALSE(address1.is_local());
-  EXPECT_EQ(epee::net_utils::ipv4_network_address::ID, address1.get_type_id());
+  EXPECT_EQ(epee::net_utils::ipv4_network_address::get_type_id(), address1.get_type_id());
+  EXPECT_EQ(epee::net_utils::zone::public_, address1.get_zone());
+  EXPECT_TRUE(address1.is_blockable());
   EXPECT_NO_THROW(address1.as<epee::net_utils::ipv4_network_address>());
   EXPECT_THROW(address1.as<custom_address>(), std::bad_cast);
 
@@ -667,7 +675,9 @@ TEST(NetUtils, NetworkAddress)
   EXPECT_STREQ("127.0.0.1", loopback.host_str().c_str());
   EXPECT_TRUE(loopback.is_loopback());
   EXPECT_FALSE(loopback.is_local());
-  EXPECT_EQ(epee::net_utils::ipv4_network_address::ID, address1.get_type_id());
+  EXPECT_EQ(epee::net_utils::ipv4_network_address::get_type_id(), address1.get_type_id());
+  EXPECT_EQ(epee::net_utils::zone::public_, address1.get_zone());
+  EXPECT_EQ(epee::net_utils::ipv4_network_address::get_type_id(), address1.get_type_id());
 
   const epee::net_utils::network_address local{
     epee::net_utils::ipv4_network_address{ip_local, 8080}
diff --git a/tests/unit_tests/net.cpp b/tests/unit_tests/net.cpp
new file mode 100644
index 000000000..a38ecfe81
--- /dev/null
+++ b/tests/unit_tests/net.cpp
@@ -0,0 +1,745 @@
+// Copyright (c) 2018, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <atomic>
+#include <boost/archive/portable_binary_oarchive.hpp>
+#include <boost/archive/portable_binary_iarchive.hpp>
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/read.hpp>
+#include <boost/asio/write.hpp>
+#include <boost/endian/conversion.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/thread/thread.hpp>
+#include <cstring>
+#include <functional>
+#include <gtest/gtest.h>
+#include <memory>
+
+#include "net/error.h"
+#include "net/net_utils_base.h"
+#include "net/socks.h"
+#include "net/parse.h"
+#include "net/tor_address.h"
+#include "p2p/net_peerlist_boost_serialization.h"
+#include "serialization/keyvalue_serialization.h"
+#include "storages/portable_storage.h"
+
+namespace
+{
+    static constexpr const char v2_onion[] =
+        "xmrto2bturnore26.onion";
+    static constexpr const char v3_onion[] =
+        "vww6ybal4bd7szmgncyruucpgfkqahzddi37ktceo3ah7ngmcopnpyyd.onion";
+}
+
+TEST(tor_address, constants)
+{
+    static_assert(!net::tor_address::is_local(), "bad is_local() response");
+    static_assert(!net::tor_address::is_loopback(), "bad is_loopback() response");
+    static_assert(net::tor_address::get_type_id() == epee::net_utils::address_type::tor, "bad get_type_id() response");
+
+    EXPECT_FALSE(net::tor_address::is_local());
+    EXPECT_FALSE(net::tor_address::is_loopback());
+    EXPECT_EQ(epee::net_utils::address_type::tor, net::tor_address::get_type_id());
+    EXPECT_EQ(epee::net_utils::address_type::tor, net::tor_address::get_type_id());
+}
+
+TEST(tor_address, invalid)
+{
+    EXPECT_TRUE(net::tor_address::make("").has_error());
+    EXPECT_TRUE(net::tor_address::make(":").has_error());
+    EXPECT_TRUE(net::tor_address::make(".onion").has_error());
+    EXPECT_TRUE(net::tor_address::make(".onion:").has_error());
+    EXPECT_TRUE(net::tor_address::make(v2_onion + 1).has_error());
+    EXPECT_TRUE(net::tor_address::make(v3_onion + 1).has_error());
+    EXPECT_TRUE(net::tor_address::make(boost::string_ref{v2_onion, sizeof(v2_onion) - 2}).has_error());
+    EXPECT_TRUE(net::tor_address::make(boost::string_ref{v3_onion, sizeof(v3_onion) - 2}).has_error());
+    EXPECT_TRUE(net::tor_address::make(std::string{v2_onion} + ":-").has_error());
+    EXPECT_TRUE(net::tor_address::make(std::string{v2_onion} + ":900a").has_error());
+    EXPECT_TRUE(net::tor_address::make(std::string{v3_onion} + ":65536").has_error());
+    EXPECT_TRUE(net::tor_address::make(std::string{v3_onion} + ":-1").has_error());
+
+    std::string onion{v3_onion};
+    onion.at(10) = 1;
+    EXPECT_TRUE(net::tor_address::make(onion).has_error());
+}
+
+TEST(tor_address, unblockable_types)
+{
+    net::tor_address tor{};
+
+    ASSERT_NE(nullptr, tor.host_str());
+    EXPECT_STREQ("<unknown tor host>", tor.host_str());
+    EXPECT_STREQ("<unknown tor host>", tor.str().c_str());
+    EXPECT_EQ(0u, tor.port());
+    EXPECT_TRUE(tor.is_unknown());
+    EXPECT_FALSE(tor.is_local());
+    EXPECT_FALSE(tor.is_loopback());
+    EXPECT_EQ(epee::net_utils::address_type::tor, tor.get_type_id());
+    EXPECT_EQ(epee::net_utils::zone::tor, tor.get_zone());
+
+    tor = net::tor_address::unknown();
+    ASSERT_NE(nullptr, tor.host_str());
+    EXPECT_STREQ("<unknown tor host>", tor.host_str());
+    EXPECT_STREQ("<unknown tor host>", tor.str().c_str());
+    EXPECT_EQ(0u, tor.port());
+    EXPECT_TRUE(tor.is_unknown());
+    EXPECT_FALSE(tor.is_local());
+    EXPECT_FALSE(tor.is_loopback());
+    EXPECT_EQ(epee::net_utils::address_type::tor, tor.get_type_id());
+    EXPECT_EQ(epee::net_utils::zone::tor, tor.get_zone());
+
+    EXPECT_EQ(net::tor_address{}, net::tor_address::unknown());
+}
+
+TEST(tor_address, valid)
+{
+    const auto address1 = net::tor_address::make(v3_onion);
+
+    ASSERT_TRUE(address1.has_value());
+    EXPECT_EQ(0u, address1->port());
+    EXPECT_STREQ(v3_onion, address1->host_str());
+    EXPECT_STREQ(v3_onion, address1->str().c_str());
+    EXPECT_TRUE(address1->is_blockable());
+
+    net::tor_address address2{*address1};
+
+    EXPECT_EQ(0u, address2.port());
+    EXPECT_STREQ(v3_onion, address2.host_str());
+    EXPECT_STREQ(v3_onion, address2.str().c_str());
+    EXPECT_TRUE(address2.is_blockable());
+    EXPECT_TRUE(address2.equal(*address1));
+    EXPECT_TRUE(address1->equal(address2));
+    EXPECT_TRUE(address2 == *address1);
+    EXPECT_TRUE(*address1 == address2);
+    EXPECT_FALSE(address2 != *address1);
+    EXPECT_FALSE(*address1 != address2);
+    EXPECT_TRUE(address2.is_same_host(*address1));
+    EXPECT_TRUE(address1->is_same_host(address2));
+    EXPECT_FALSE(address2.less(*address1));
+    EXPECT_FALSE(address1->less(address2));
+
+    address2 = MONERO_UNWRAP(net::tor_address::make(std::string{v2_onion} + ":6545"));
+
+    EXPECT_EQ(6545, address2.port());
+    EXPECT_STREQ(v2_onion, address2.host_str());
+    EXPECT_EQ(std::string{v2_onion} + ":6545", address2.str().c_str());
+    EXPECT_TRUE(address2.is_blockable());
+    EXPECT_FALSE(address2.equal(*address1));
+    EXPECT_FALSE(address1->equal(address2));
+    EXPECT_FALSE(address2 == *address1);
+    EXPECT_FALSE(*address1 == address2);
+    EXPECT_TRUE(address2 != *address1);
+    EXPECT_TRUE(*address1 != address2);
+    EXPECT_FALSE(address2.is_same_host(*address1));
+    EXPECT_FALSE(address1->is_same_host(address2));
+    EXPECT_FALSE(address2.less(*address1));
+    EXPECT_TRUE(address1->less(address2));
+
+    address2 = MONERO_UNWRAP(net::tor_address::make(std::string{v3_onion} + ":", 65535));
+
+    EXPECT_EQ(65535, address2.port());
+    EXPECT_STREQ(v3_onion, address2.host_str());
+    EXPECT_EQ(std::string{v3_onion} + ":65535", address2.str().c_str());
+    EXPECT_TRUE(address2.is_blockable());
+    EXPECT_FALSE(address2.equal(*address1));
+    EXPECT_FALSE(address1->equal(address2));
+    EXPECT_FALSE(address2 == *address1);
+    EXPECT_FALSE(*address1 == address2);
+    EXPECT_TRUE(address2 != *address1);
+    EXPECT_TRUE(*address1 != address2);
+    EXPECT_TRUE(address2.is_same_host(*address1));
+    EXPECT_TRUE(address1->is_same_host(address2));
+    EXPECT_FALSE(address2.less(*address1));
+    EXPECT_TRUE(address1->less(address2));
+}
+
+TEST(tor_address, generic_network_address)
+{
+    const epee::net_utils::network_address tor1{MONERO_UNWRAP(net::tor_address::make(v3_onion, 8080))};
+    const epee::net_utils::network_address tor2{MONERO_UNWRAP(net::tor_address::make(v3_onion, 8080))};
+    const epee::net_utils::network_address ip{epee::net_utils::ipv4_network_address{100, 200}};
+
+    EXPECT_EQ(tor1, tor2);
+    EXPECT_NE(ip, tor1);
+    EXPECT_LT(ip, tor1);
+
+    EXPECT_STREQ(v3_onion, tor1.host_str().c_str());
+    EXPECT_EQ(std::string{v3_onion} + ":8080", tor1.str());
+    EXPECT_EQ(epee::net_utils::address_type::tor, tor1.get_type_id());
+    EXPECT_EQ(epee::net_utils::address_type::tor, tor2.get_type_id());
+    EXPECT_EQ(epee::net_utils::address_type::ipv4, ip.get_type_id());
+    EXPECT_EQ(epee::net_utils::zone::tor, tor1.get_zone());
+    EXPECT_EQ(epee::net_utils::zone::tor, tor2.get_zone());
+    EXPECT_EQ(epee::net_utils::zone::public_, ip.get_zone());
+    EXPECT_TRUE(tor1.is_blockable());
+    EXPECT_TRUE(tor2.is_blockable());
+    EXPECT_TRUE(ip.is_blockable());
+}
+
+namespace
+{
+    struct test_command
+    {
+        net::tor_address tor;
+
+        BEGIN_KV_SERIALIZE_MAP()
+            KV_SERIALIZE(tor);
+        END_KV_SERIALIZE_MAP()
+    };
+}
+
+TEST(tor_address, epee_serializev_v2)
+{
+    std::string buffer{};
+    {
+        test_command command{MONERO_UNWRAP(net::tor_address::make(v2_onion, 10))};
+        EXPECT_FALSE(command.tor.is_unknown());
+        EXPECT_NE(net::tor_address{}, command.tor);
+        EXPECT_STREQ(v2_onion, command.tor.host_str());
+        EXPECT_EQ(10u, command.tor.port());
+
+        epee::serialization::portable_storage stg{};
+        EXPECT_TRUE(command.store(stg));
+        EXPECT_TRUE(stg.store_to_binary(buffer));
+    }
+
+    test_command command{};
+    {
+        EXPECT_TRUE(command.tor.is_unknown());
+        EXPECT_EQ(net::tor_address{}, command.tor);
+        EXPECT_STREQ(net::tor_address::unknown_str(), command.tor.host_str());
+        EXPECT_EQ(0u, command.tor.port());
+
+        epee::serialization::portable_storage stg{};
+        EXPECT_TRUE(stg.load_from_binary(buffer));
+        EXPECT_TRUE(command.load(stg));
+    }
+    EXPECT_FALSE(command.tor.is_unknown());
+    EXPECT_NE(net::tor_address{}, command.tor);
+    EXPECT_STREQ(v2_onion, command.tor.host_str());
+    EXPECT_EQ(10u, command.tor.port());
+
+    // make sure that exceeding max buffer doesn't destroy tor_address::_load
+    {
+        epee::serialization::portable_storage stg{};
+        stg.load_from_binary(buffer);
+
+        std::string host{};
+        ASSERT_TRUE(stg.get_value("host", host, stg.open_section("tor", nullptr, false)));
+        EXPECT_EQ(std::strlen(v2_onion), host.size());
+
+        host.push_back('k');
+        EXPECT_TRUE(stg.set_value("host", host, stg.open_section("tor", nullptr, false)));
+        EXPECT_TRUE(command.load(stg)); // poor error reporting from `KV_SERIALIZE`
+    }
+
+    EXPECT_TRUE(command.tor.is_unknown());
+    EXPECT_EQ(net::tor_address{}, command.tor);
+    EXPECT_STREQ(net::tor_address::unknown_str(), command.tor.host_str());
+    EXPECT_EQ(0u, command.tor.port());
+}
+
+TEST(tor_address, epee_serializev_v3)
+{
+    std::string buffer{};
+    {
+        test_command command{MONERO_UNWRAP(net::tor_address::make(v3_onion, 10))};
+        EXPECT_FALSE(command.tor.is_unknown());
+        EXPECT_NE(net::tor_address{}, command.tor);
+        EXPECT_STREQ(v3_onion, command.tor.host_str());
+        EXPECT_EQ(10u, command.tor.port());
+
+        epee::serialization::portable_storage stg{};
+        EXPECT_TRUE(command.store(stg));
+        EXPECT_TRUE(stg.store_to_binary(buffer));
+    }
+
+    test_command command{};
+    {
+        EXPECT_TRUE(command.tor.is_unknown());
+        EXPECT_EQ(net::tor_address{}, command.tor);
+        EXPECT_STREQ(net::tor_address::unknown_str(), command.tor.host_str());
+        EXPECT_EQ(0u, command.tor.port());
+
+        epee::serialization::portable_storage stg{};
+        EXPECT_TRUE(stg.load_from_binary(buffer));
+        EXPECT_TRUE(command.load(stg));
+    }
+    EXPECT_FALSE(command.tor.is_unknown());
+    EXPECT_NE(net::tor_address{}, command.tor);
+    EXPECT_STREQ(v3_onion, command.tor.host_str());
+    EXPECT_EQ(10u, command.tor.port());
+
+    // make sure that exceeding max buffer doesn't destroy tor_address::_load
+    {
+        epee::serialization::portable_storage stg{};
+        stg.load_from_binary(buffer);
+
+        std::string host{};
+        ASSERT_TRUE(stg.get_value("host", host, stg.open_section("tor", nullptr, false)));
+        EXPECT_EQ(std::strlen(v3_onion), host.size());
+
+        host.push_back('k');
+        EXPECT_TRUE(stg.set_value("host", host, stg.open_section("tor", nullptr, false)));
+        EXPECT_TRUE(command.load(stg)); // poor error reporting from `KV_SERIALIZE`
+    }
+
+    EXPECT_TRUE(command.tor.is_unknown());
+    EXPECT_EQ(net::tor_address{}, command.tor);
+    EXPECT_STRNE(v3_onion, command.tor.host_str());
+    EXPECT_EQ(0u, command.tor.port());
+}
+
+TEST(tor_address, epee_serialize_unknown)
+{
+    std::string buffer{};
+    {
+        test_command command{net::tor_address::unknown()};
+        EXPECT_TRUE(command.tor.is_unknown());
+        EXPECT_EQ(net::tor_address{}, command.tor);
+        EXPECT_STREQ(net::tor_address::unknown_str(), command.tor.host_str());
+        EXPECT_EQ(0u, command.tor.port());
+
+        epee::serialization::portable_storage stg{};
+        EXPECT_TRUE(command.store(stg));
+        EXPECT_TRUE(stg.store_to_binary(buffer));
+    }
+
+    test_command command{};
+    {
+        EXPECT_TRUE(command.tor.is_unknown());
+        EXPECT_EQ(net::tor_address{}, command.tor);
+        EXPECT_STRNE(v3_onion, command.tor.host_str());
+        EXPECT_EQ(0u, command.tor.port());
+
+        epee::serialization::portable_storage stg{};
+        EXPECT_TRUE(stg.load_from_binary(buffer));
+        EXPECT_TRUE(command.load(stg));
+    }
+    EXPECT_TRUE(command.tor.is_unknown());
+    EXPECT_EQ(net::tor_address{}, command.tor);
+    EXPECT_STREQ(net::tor_address::unknown_str(), command.tor.host_str());
+    EXPECT_EQ(0u, command.tor.port());
+
+    // make sure that exceeding max buffer doesn't destroy tor_address::_load
+    {
+        epee::serialization::portable_storage stg{};
+        stg.load_from_binary(buffer);
+
+        std::string host{};
+        ASSERT_TRUE(stg.get_value("host", host, stg.open_section("tor", nullptr, false)));
+        EXPECT_EQ(std::strlen(net::tor_address::unknown_str()), host.size());
+
+        host.push_back('k');
+        EXPECT_TRUE(stg.set_value("host", host, stg.open_section("tor", nullptr, false)));
+        EXPECT_TRUE(command.load(stg)); // poor error reporting from `KV_SERIALIZE`
+    }
+
+    EXPECT_TRUE(command.tor.is_unknown());
+    EXPECT_EQ(net::tor_address{}, command.tor);
+    EXPECT_STRNE(v3_onion, command.tor.host_str());
+    EXPECT_EQ(0u, command.tor.port());
+}
+
+TEST(tor_address, boost_serialize_v2)
+{
+    std::string buffer{};
+    {
+        const net::tor_address tor = MONERO_UNWRAP(net::tor_address::make(v2_onion, 10));
+        EXPECT_FALSE(tor.is_unknown());
+        EXPECT_NE(net::tor_address{}, tor);
+        EXPECT_STREQ(v2_onion, tor.host_str());
+        EXPECT_EQ(10u, tor.port());
+
+        std::ostringstream stream{};
+        {
+            boost::archive::portable_binary_oarchive archive{stream};
+            archive << tor;
+        }
+        buffer = stream.str();
+    }
+
+    net::tor_address tor{};
+    {
+        EXPECT_TRUE(tor.is_unknown());
+        EXPECT_EQ(net::tor_address{}, tor);
+        EXPECT_STREQ(net::tor_address::unknown_str(), tor.host_str());
+        EXPECT_EQ(0u, tor.port());
+
+        std::istringstream stream{buffer};
+        boost::archive::portable_binary_iarchive archive{stream};
+        archive >> tor;
+    }
+    EXPECT_FALSE(tor.is_unknown());
+    EXPECT_NE(net::tor_address{}, tor);
+    EXPECT_STREQ(v2_onion, tor.host_str());
+    EXPECT_EQ(10u, tor.port());
+}
+
+TEST(tor_address, boost_serialize_v3)
+{
+    std::string buffer{};
+    {
+        const net::tor_address tor = MONERO_UNWRAP(net::tor_address::make(v3_onion, 10));
+        EXPECT_FALSE(tor.is_unknown());
+        EXPECT_NE(net::tor_address{}, tor);
+        EXPECT_STREQ(v3_onion, tor.host_str());
+        EXPECT_EQ(10u, tor.port());
+
+        std::ostringstream stream{};
+        {
+            boost::archive::portable_binary_oarchive archive{stream};
+            archive << tor;
+        }
+        buffer = stream.str();
+    }
+
+    net::tor_address tor{};
+    {
+        EXPECT_TRUE(tor.is_unknown());
+        EXPECT_EQ(net::tor_address{}, tor);
+        EXPECT_STREQ(net::tor_address::unknown_str(), tor.host_str());
+        EXPECT_EQ(0u, tor.port());
+
+        std::istringstream stream{buffer};
+        boost::archive::portable_binary_iarchive archive{stream};
+        archive >> tor;
+    }
+    EXPECT_FALSE(tor.is_unknown());
+    EXPECT_NE(net::tor_address{}, tor);
+    EXPECT_STREQ(v3_onion, tor.host_str());
+    EXPECT_EQ(10u, tor.port());
+}
+
+TEST(tor_address, boost_serialize_unknown)
+{
+    std::string buffer{};
+    {
+        const net::tor_address tor{};
+        EXPECT_TRUE(tor.is_unknown());
+        EXPECT_EQ(net::tor_address::unknown(), tor);
+        EXPECT_STREQ(net::tor_address::unknown_str(), tor.host_str());
+        EXPECT_EQ(0u, tor.port());
+
+        std::ostringstream stream{};
+        {
+            boost::archive::portable_binary_oarchive archive{stream};
+            archive << tor;
+        }
+        buffer = stream.str();
+    }
+
+    net::tor_address tor{};
+    {
+        EXPECT_TRUE(tor.is_unknown());
+        EXPECT_EQ(net::tor_address{}, tor);
+        EXPECT_STREQ(net::tor_address::unknown_str(), tor.host_str());
+        EXPECT_EQ(0u, tor.port());
+
+        std::istringstream stream{buffer};
+        boost::archive::portable_binary_iarchive archive{stream};
+        archive >> tor;
+    }
+    EXPECT_TRUE(tor.is_unknown());
+    EXPECT_EQ(net::tor_address::unknown(), tor);
+    EXPECT_STREQ(net::tor_address::unknown_str(), tor.host_str());
+    EXPECT_EQ(0u, tor.port());
+}
+
+TEST(get_network_address, onion)
+{
+    expect<epee::net_utils::network_address> address =
+        net::get_network_address("onion", 0);
+    EXPECT_EQ(net::error::unsupported_address, address);
+
+    address = net::get_network_address(".onion", 0);
+    EXPECT_EQ(net::error::invalid_tor_address, address);
+
+    address = net::get_network_address(v3_onion, 1000);
+    ASSERT_TRUE(bool(address));
+    EXPECT_EQ(epee::net_utils::address_type::tor, address->get_type_id());
+    EXPECT_STREQ(v3_onion, address->host_str().c_str());
+    EXPECT_EQ(std::string{v3_onion} + ":1000", address->str());
+
+    address = net::get_network_address(std::string{v3_onion} + ":2000", 1000);
+    ASSERT_TRUE(bool(address));
+    EXPECT_EQ(epee::net_utils::address_type::tor, address->get_type_id());
+    EXPECT_STREQ(v3_onion, address->host_str().c_str());
+    EXPECT_EQ(std::string{v3_onion} + ":2000", address->str());
+
+    address = net::get_network_address(std::string{v3_onion} + ":65536", 1000);
+    EXPECT_EQ(net::error::invalid_port, address);
+}
+
+
+TEST(get_network_address, ipv4)
+{
+    expect<epee::net_utils::network_address> address =
+        net::get_network_address("0.0.0.", 0);
+    EXPECT_EQ(net::error::unsupported_address, address);
+
+    address = net::get_network_address("0.0.0.257", 0);
+    EXPECT_EQ(net::error::unsupported_address, address);
+
+    address = net::get_network_address("0.0.0.254", 1000);
+    ASSERT_TRUE(bool(address));
+    EXPECT_EQ(epee::net_utils::address_type::ipv4, address->get_type_id());
+    EXPECT_STREQ("0.0.0.254", address->host_str().c_str());
+    EXPECT_STREQ("0.0.0.254:1000", address->str().c_str());
+
+    address = net::get_network_address("23.0.0.254:2000", 1000);
+    ASSERT_TRUE(bool(address));
+    EXPECT_EQ(epee::net_utils::address_type::ipv4, address->get_type_id());
+    EXPECT_STREQ("23.0.0.254", address->host_str().c_str());
+    EXPECT_STREQ("23.0.0.254:2000", address->str().c_str());
+}
+
+namespace
+{
+    using stream_type = boost::asio::ip::tcp;
+
+    struct io_thread
+    {
+        boost::asio::io_service io_service;
+        boost::asio::io_service::work work;
+        stream_type::socket server;
+        stream_type::acceptor acceptor;
+        boost::thread io;
+        std::atomic<bool> connected;
+
+        io_thread()
+          : io_service(),
+            work(io_service),
+            server(io_service),
+            acceptor(io_service),
+            io([this] () { try { this->io_service.run(); } catch (const std::exception& e) { MERROR(e.what()); }}),
+            connected(false)
+        {
+            acceptor.open(boost::asio::ip::tcp::v4());
+            acceptor.bind(stream_type::endpoint{boost::asio::ip::tcp::v4(), 0});
+            acceptor.listen();
+            acceptor.async_accept(server, [this] (boost::system::error_code error) {
+                this->connected = true;
+                if (error)
+                    throw boost::system::system_error{error};
+            });
+        }
+
+        ~io_thread() noexcept
+        {
+            io_service.stop();
+            if (io.joinable())
+                io.join();
+        }
+    };
+
+    struct checked_client
+    {
+        std::atomic<bool>* called_;
+        bool expected_;
+
+        void operator()(boost::system::error_code error, net::socks::client::stream_type::socket&&) const
+        {
+            EXPECT_EQ(expected_, bool(error)) << "Socks server: " << error.message();
+            ASSERT_TRUE(called_ != nullptr);
+            (*called_) = true;
+        }
+    };
+}
+
+TEST(socks_client, unsupported_command)
+{
+    boost::asio::io_service io_service{};
+    stream_type::socket client{io_service};
+
+    auto test_client = net::socks::make_connect_client(
+        std::move(client), net::socks::version::v4, std::bind( [] {} )
+    );
+    ASSERT_TRUE(bool(test_client));
+    EXPECT_TRUE(test_client->buffer().empty());
+
+    EXPECT_FALSE(test_client->set_connect_command("example.com", 8080));
+    EXPECT_TRUE(test_client->buffer().empty());
+
+    EXPECT_FALSE(test_client->set_resolve_command("example.com"));
+    EXPECT_TRUE(test_client->buffer().empty());
+}
+
+TEST(socks_client, no_command)
+{
+    boost::asio::io_service io_service{};
+    stream_type::socket client{io_service};
+
+    auto test_client = net::socks::make_connect_client(
+        std::move(client), net::socks::version::v4a, std::bind( [] {} )
+    );
+    ASSERT_TRUE(bool(test_client));
+    EXPECT_FALSE(net::socks::client::send(std::move(test_client)));
+}
+
+TEST(socks_client, connect_command)
+{
+    io_thread io{};
+    stream_type::socket client{io.io_service};
+
+    std::atomic<bool> called{false};
+    auto test_client = net::socks::make_connect_client(
+        std::move(client), net::socks::version::v4a, checked_client{std::addressof(called), false}
+    );
+    ASSERT_TRUE(bool(test_client));
+
+    ASSERT_TRUE(test_client->set_connect_command("example.com", 8080));
+    EXPECT_FALSE(test_client->buffer().empty());
+    ASSERT_TRUE(net::socks::client::connect_and_send(std::move(test_client), io.acceptor.local_endpoint()));
+    while (!io.connected);
+
+    const std::uint8_t expected_bytes[] = {
+        4, 1, 0x1f, 0x90, 0x00, 0x00, 0x00, 0x01, 0x00,
+        'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', 0x00
+    };
+
+    std::uint8_t actual_bytes[sizeof(expected_bytes)];
+    boost::asio::read(io.server, boost::asio::buffer(actual_bytes));
+    EXPECT_TRUE(std::memcmp(expected_bytes, actual_bytes, sizeof(actual_bytes)) == 0);
+
+    const std::uint8_t reply_bytes[] = {0, 90, 0, 0, 0, 0, 0, 0};
+    boost::asio::write(io.server, boost::asio::buffer(reply_bytes));
+
+    // yikes!
+    while (!called);
+}
+
+TEST(socks_client, connect_command_failed)
+{
+    io_thread io{};
+    stream_type::socket client{io.io_service};
+
+    std::atomic<bool> called{false};
+    auto test_client = net::socks::make_connect_client(
+        std::move(client), net::socks::version::v4, checked_client{std::addressof(called), true}
+    );
+    ASSERT_TRUE(bool(test_client));
+
+    ASSERT_TRUE(
+        test_client->set_connect_command(
+            epee::net_utils::ipv4_network_address{boost::endian::native_to_big(std::uint32_t(5000)), 3000}
+        )
+    );
+    EXPECT_FALSE(test_client->buffer().empty());
+    ASSERT_TRUE(net::socks::client::connect_and_send(std::move(test_client), io.acceptor.local_endpoint()));
+    while (!io.connected);
+
+    const std::uint8_t expected_bytes[] = {
+        4, 1, 0x0b, 0xb8, 0x00, 0x00, 0x13, 0x88, 0x00
+    };
+
+    std::uint8_t actual_bytes[sizeof(expected_bytes)];
+    boost::asio::read(io.server, boost::asio::buffer(actual_bytes));
+    EXPECT_TRUE(std::memcmp(expected_bytes, actual_bytes, sizeof(actual_bytes)) == 0);
+
+    const std::uint8_t reply_bytes[] = {0, 91, 0, 0, 0, 0, 0, 0};
+    boost::asio::write(io.server, boost::asio::buffer(reply_bytes));
+
+    // yikes!
+    while (!called);
+}
+
+TEST(socks_client, resolve_command)
+{
+    static std::uint8_t reply_bytes[] = {0, 90, 0, 0, 0xff, 0, 0xad, 0};
+
+    struct resolve_client : net::socks::client
+    {
+        std::atomic<unsigned> called_;
+        bool expected_;
+
+        resolve_client(stream_type::socket&& proxy)
+          : net::socks::client(std::move(proxy), net::socks::version::v4a_tor)
+          , called_(0)
+          , expected_(false)
+        {};
+
+        virtual void done(boost::system::error_code error, std::shared_ptr<client> self) override
+        {
+            EXPECT_EQ(this, self.get());
+            EXPECT_EQ(expected_, bool(error)) << "Resolve failure: " << error.message();
+
+            if (!error)
+            {
+                ASSERT_EQ(sizeof(reply_bytes), buffer().size());
+                EXPECT_EQ(0u, std::memcmp(buffer().data(), reply_bytes, sizeof(reply_bytes)));
+            }
+
+            ++called_;
+        }
+    };
+
+    io_thread io{};
+    stream_type::socket client{io.io_service};
+
+    auto test_client = std::make_shared<resolve_client>(std::move(client));
+    ASSERT_TRUE(bool(test_client));
+
+    ASSERT_TRUE(test_client->set_resolve_command("example.com"));
+    EXPECT_FALSE(test_client->buffer().empty());
+    ASSERT_TRUE(net::socks::client::connect_and_send(test_client, io.acceptor.local_endpoint()));
+    while (!io.connected);
+
+    const std::uint8_t expected_bytes[] = {
+        4, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+        'e', 'x', 'a', 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm', 0x00
+    };
+
+    std::uint8_t actual_bytes[sizeof(expected_bytes)];
+    boost::asio::read(io.server, boost::asio::buffer(actual_bytes));
+    EXPECT_TRUE(std::memcmp(expected_bytes, actual_bytes, sizeof(actual_bytes)) == 0);
+
+    boost::asio::write(io.server, boost::asio::buffer(reply_bytes));
+
+    // yikes!
+    while (test_client->called_ == 0);
+
+    test_client->expected_ = true;
+    ASSERT_TRUE(test_client->set_resolve_command("example.com"));
+    EXPECT_FALSE(test_client->buffer().empty());
+    ASSERT_TRUE(net::socks::client::send(test_client));
+
+    boost::asio::read(io.server, boost::asio::buffer(actual_bytes));
+    EXPECT_TRUE(std::memcmp(expected_bytes, actual_bytes, sizeof(actual_bytes)) == 0);
+
+    reply_bytes[1] = 91;
+    boost::asio::write(io.server, boost::asio::buffer(reply_bytes));
+
+    // yikes!
+    while (test_client->called_ == 1);
+}
+
+
diff --git a/tests/unit_tests/test_peerlist.cpp b/tests/unit_tests/test_peerlist.cpp
index f638c6251..03aa48ea0 100644
--- a/tests/unit_tests/test_peerlist.cpp
+++ b/tests/unit_tests/test_peerlist.cpp
@@ -37,7 +37,7 @@
 TEST(peer_list, peer_list_general)
 {
   nodetool::peerlist_manager plm;
-  plm.init(false);
+  plm.init(nodetool::peerlist_types{}, false);
 #define MAKE_IPV4_ADDRESS(a,b,c,d,e) epee::net_utils::ipv4_network_address{MAKE_IP(a,b,c,d),e}
 #define ADD_GRAY_NODE(addr_, id_, last_seen_) {  nodetool::peerlist_entry ple; ple.last_seen=last_seen_;ple.adr = addr_; ple.id = id_;plm.append_with_peer_gray(ple);}  
 #define ADD_WHITE_NODE(addr_, id_, last_seen_) {  nodetool::peerlist_entry ple;ple.last_seen=last_seen_; ple.adr = addr_; ple.id = id_;plm.append_with_peer_white(ple);}  
@@ -77,9 +77,180 @@ TEST(peer_list, merge_peer_lists)
   //([^ \t]*)\t([^ \t]*):([^ \t]*) \tlast_seen: d(\d+)\.h(\d+)\.m(\d+)\.s(\d+)\n
   //ADD_NODE_TO_PL("\2", \3, 0x\1, (1353346618 -(\4*60*60*24+\5*60*60+\6*60+\7 )));\n
   nodetool::peerlist_manager plm;
-  plm.init(false);
+  plm.init(nodetool::peerlist_types{}, false);
   std::vector<nodetool::peerlist_entry> outer_bs;
 #define ADD_NODE_TO_PL(ip_, port_, id_, timestamp_) {  nodetool::peerlist_entry ple; epee::string_tools::get_ip_int32_from_string(ple.adr.ip, ip_); ple.last_seen = timestamp_; ple.adr.port = port_; ple.id = id_;outer_bs.push_back(ple);}  
+}
+
+namespace
+{
+  bool check_empty(nodetool::peerlist_storage& peers, std::initializer_list<epee::net_utils::zone> zones)
+  {
+    bool pass = false;
+    for (const epee::net_utils::zone zone : zones)
+    {
+      const nodetool::peerlist_types types{peers.take_zone(zone)};
+      EXPECT_TRUE(types.white.empty());
+      EXPECT_TRUE(types.gray.empty());
+      EXPECT_TRUE(types.anchor.empty());
+      pass = (types.white.empty() && types.gray.empty() && types.anchor.empty());
+    }
+    return pass;
+  }
+}
+
+TEST(peerlist_storage, store)
+{
+
+  using address_type = epee::net_utils::address_type;
+  using zone = epee::net_utils::zone;
+
+  nodetool::peerlist_storage peers{};
+  EXPECT_TRUE(check_empty(peers, {zone::invalid, zone::public_, zone::tor, zone::i2p}));
+
+  std::string buffer{};
+  {
+    nodetool::peerlist_types types{};
+    types.white.push_back({epee::net_utils::ipv4_network_address{1000, 10}, 44, 55});
+    types.white.push_back({net::tor_address::unknown(), 64, 75});
+    types.gray.push_back({net::tor_address::unknown(), 99, 88});
+    types.gray.push_back({epee::net_utils::ipv4_network_address{2000, 20}, 84, 45});
+    types.anchor.push_back({epee::net_utils::ipv4_network_address{999, 654}, 444, 555});
+    types.anchor.push_back({net::tor_address::unknown(), 14, 33});
+    types.anchor.push_back({net::tor_address::unknown(), 24, 22});
+
+    std::ostringstream stream{};
+    EXPECT_TRUE(peers.store(stream, types));
+    buffer = stream.str();
+  }
+  EXPECT_TRUE(check_empty(peers, {zone::invalid, zone::public_, zone::tor, zone::i2p}));
+  {
+    std::istringstream stream{buffer};
+    boost::optional<nodetool::peerlist_storage> read_peers =
+      nodetool::peerlist_storage::open(stream, true);
+    ASSERT_TRUE(bool(read_peers));
+    peers = std::move(*read_peers);
+  }
+  EXPECT_TRUE(check_empty(peers, {zone::invalid, zone::i2p}));
+
+  nodetool::peerlist_types types = peers.take_zone(zone::public_);
+  EXPECT_TRUE(check_empty(peers, {zone::invalid, zone::public_, zone::i2p}));
+
+  ASSERT_EQ(1u, types.white.size());
+  ASSERT_EQ(address_type::ipv4, types.white[0].adr.get_type_id());
+  EXPECT_EQ(1000u, types.white[0].adr.template as<epee::net_utils::ipv4_network_address>().ip());
+  EXPECT_EQ(10u, types.white[0].adr.template as<epee::net_utils::ipv4_network_address>().port());
+  EXPECT_EQ(44u, types.white[0].id);
+  EXPECT_EQ(55u, types.white[0].last_seen);
+
+  ASSERT_EQ(1u, types.gray.size());
+  ASSERT_EQ(address_type::ipv4, types.gray[0].adr.get_type_id());
+  EXPECT_EQ(2000u, types.gray[0].adr.template as<epee::net_utils::ipv4_network_address>().ip());
+  EXPECT_EQ(20u, types.gray[0].adr.template as<epee::net_utils::ipv4_network_address>().port());
+  EXPECT_EQ(84u, types.gray[0].id);
+  EXPECT_EQ(45u, types.gray[0].last_seen);
+
+  ASSERT_EQ(1u, types.anchor.size());
+  ASSERT_EQ(address_type::ipv4, types.anchor[0].adr.get_type_id());
+  EXPECT_EQ(999u, types.anchor[0].adr.template as<epee::net_utils::ipv4_network_address>().ip());
+  EXPECT_EQ(654u, types.anchor[0].adr.template as<epee::net_utils::ipv4_network_address>().port());
+  EXPECT_EQ(444u, types.anchor[0].id);
+  EXPECT_EQ(555u, types.anchor[0].first_seen);
+  {
+    std::ostringstream stream{};
+    EXPECT_TRUE(peers.store(stream, types));
+    buffer = stream.str();
+  }
+  EXPECT_TRUE(check_empty(peers, {zone::invalid, zone::public_, zone::i2p}));
+
+  types = peers.take_zone(zone::tor);
+  EXPECT_TRUE(check_empty(peers, {zone::invalid, zone::public_, zone::i2p, zone::tor}));
+
+  ASSERT_EQ(1u, types.white.size());
+  ASSERT_EQ(address_type::tor, types.white[0].adr.get_type_id());
+  EXPECT_STREQ(net::tor_address::unknown_str(), types.white[0].adr.template as<net::tor_address>().host_str());
+  EXPECT_EQ(0u, types.white[0].adr.template as<net::tor_address>().port());
+  EXPECT_EQ(64u, types.white[0].id);
+  EXPECT_EQ(75u, types.white[0].last_seen);
+
+  ASSERT_EQ(1u, types.gray.size());
+  ASSERT_EQ(address_type::tor, types.gray[0].adr.get_type_id());
+  EXPECT_STREQ(net::tor_address::unknown_str(), types.gray[0].adr.template as<net::tor_address>().host_str());
+  EXPECT_EQ(0u, types.gray[0].adr.template as<net::tor_address>().port());
+  EXPECT_EQ(99u, types.gray[0].id);
+  EXPECT_EQ(88u, types.gray[0].last_seen);
+
+  ASSERT_EQ(2u, types.anchor.size());
+  ASSERT_EQ(address_type::tor, types.anchor[0].adr.get_type_id());
+  EXPECT_STREQ(net::tor_address::unknown_str(), types.anchor[0].adr.template as<net::tor_address>().host_str());
+  EXPECT_EQ(0u, types.anchor[0].adr.template as<net::tor_address>().port());
+  EXPECT_EQ(14u, types.anchor[0].id);
+  EXPECT_EQ(33u, types.anchor[0].first_seen);
+  ASSERT_EQ(address_type::tor, types.anchor[1].adr.get_type_id());
+  EXPECT_STREQ(net::tor_address::unknown_str(), types.anchor[1].adr.template as<net::tor_address>().host_str());
+  EXPECT_EQ(0u, types.anchor[1].adr.template as<net::tor_address>().port());
+  EXPECT_EQ(24u, types.anchor[1].id);
+  EXPECT_EQ(22u, types.anchor[1].first_seen);
+
+  {
+    std::istringstream stream{buffer};
+    boost::optional<nodetool::peerlist_storage> read_peers =
+      nodetool::peerlist_storage::open(stream, true);
+    ASSERT_TRUE(bool(read_peers));
+    peers = std::move(*read_peers);
+  }
+  EXPECT_TRUE(check_empty(peers, {zone::invalid, zone::i2p}));
+
+  types = peers.take_zone(zone::public_);
+  EXPECT_TRUE(check_empty(peers, {zone::invalid, zone::public_, zone::i2p}));
+
+  ASSERT_EQ(1u, types.white.size());
+  ASSERT_EQ(address_type::ipv4, types.white[0].adr.get_type_id());
+  EXPECT_EQ(1000u, types.white[0].adr.template as<epee::net_utils::ipv4_network_address>().ip());
+  EXPECT_EQ(10u, types.white[0].adr.template as<epee::net_utils::ipv4_network_address>().port());
+  EXPECT_EQ(44u, types.white[0].id);
+  EXPECT_EQ(55u, types.white[0].last_seen);
+
+  ASSERT_EQ(1u, types.gray.size());
+  ASSERT_EQ(address_type::ipv4, types.gray[0].adr.get_type_id());
+  EXPECT_EQ(2000u, types.gray[0].adr.template as<epee::net_utils::ipv4_network_address>().ip());
+  EXPECT_EQ(20u, types.gray[0].adr.template as<epee::net_utils::ipv4_network_address>().port());
+  EXPECT_EQ(84u, types.gray[0].id);
+  EXPECT_EQ(45u, types.gray[0].last_seen);
+
+  ASSERT_EQ(1u, types.anchor.size());
+  ASSERT_EQ(address_type::ipv4, types.anchor[0].adr.get_type_id());
+  EXPECT_EQ(999u, types.anchor[0].adr.template as<epee::net_utils::ipv4_network_address>().ip());
+  EXPECT_EQ(654u, types.anchor[0].adr.template as<epee::net_utils::ipv4_network_address>().port());
+  EXPECT_EQ(444u, types.anchor[0].id);
+  EXPECT_EQ(555u, types.anchor[0].first_seen);
+
+  types = peers.take_zone(zone::tor);
+  EXPECT_TRUE(check_empty(peers, {zone::invalid, zone::public_, zone::i2p, zone::tor}));
+
+  ASSERT_EQ(1u, types.white.size());
+  ASSERT_EQ(address_type::tor, types.white[0].adr.get_type_id());
+  EXPECT_STREQ(net::tor_address::unknown_str(), types.white[0].adr.template as<net::tor_address>().host_str());
+  EXPECT_EQ(0u, types.white[0].adr.template as<net::tor_address>().port());
+  EXPECT_EQ(64u, types.white[0].id);
+  EXPECT_EQ(75u, types.white[0].last_seen);
 
+  ASSERT_EQ(1u, types.gray.size());
+  ASSERT_EQ(address_type::tor, types.gray[0].adr.get_type_id());
+  EXPECT_STREQ(net::tor_address::unknown_str(), types.gray[0].adr.template as<net::tor_address>().host_str());
+  EXPECT_EQ(0u, types.gray[0].adr.template as<net::tor_address>().port());
+  EXPECT_EQ(99u, types.gray[0].id);
+  EXPECT_EQ(88u, types.gray[0].last_seen);
 
+  ASSERT_EQ(2u, types.anchor.size());
+  ASSERT_EQ(address_type::tor, types.anchor[0].adr.get_type_id());
+  EXPECT_STREQ(net::tor_address::unknown_str(), types.anchor[0].adr.template as<net::tor_address>().host_str());
+  EXPECT_EQ(0u, types.anchor[0].adr.template as<net::tor_address>().port());
+  EXPECT_EQ(14u, types.anchor[0].id);
+  EXPECT_EQ(33u, types.anchor[0].first_seen);
+  ASSERT_EQ(address_type::tor, types.anchor[1].adr.get_type_id());
+  EXPECT_STREQ(net::tor_address::unknown_str(), types.anchor[1].adr.template as<net::tor_address>().host_str());
+  EXPECT_EQ(0u, types.anchor[1].adr.template as<net::tor_address>().port());
+  EXPECT_EQ(24u, types.anchor[1].id);
+  EXPECT_EQ(22u, types.anchor[1].first_seen);
 }