refactor

CMakeLists.txt

@@ -756,7 +756,8 @@ else()
 
   add_library(${STATIC_LIB} STATIC ${LIB_SRC})
   add_library(${UTIL_LIB} STATIC ${LIB_UTIL_SRC})
-
+  target_link_libraries(${UTIL_LIB} absl::variant)
+  
 # cut back on fluff
 if (NOT WIN32)
   target_link_libraries(${UTIL_LIB} absl::optional)

llarp/dht/bucket.hpp

@@ -21,16 +21,15 @@ namespace llarp
 
       Bucket(const Key_t& us, Random_t r) : nodes(XorMetric(us)), random(r){};
 
-      void
-      ExtractStatus(util::StatusObject& obj) const override
+      util::StatusObject
+      ExtractStatus() const override
       {
+        util::StatusObject obj{};
         for(const auto& item : nodes)
         {
-          std::string keyname = item.first.ToHex();
-          util::StatusObject itemObj;
-          item.second.ExtractStatus(itemObj);
-          obj.PutObject(keyname.c_str(), itemObj);
+          obj.Put(item.first.ToHex(), item.second.ExtractStatus());
         }
+        return obj;
       }
 
       size_t

llarp/dht/context.cpp

@@ -222,26 +222,18 @@ namespace llarp
       pendingExploreLookups.Expire(now);
     }
 
-    void
-    Context::ExtractStatus(util::StatusObject &obj) const
+    util::StatusObject
+    Context::ExtractStatus() const
     {
-      util::StatusObject pendingRouterObj, pendingIntrosetObj, pendingTagObj,
-          pendingExploreObj, routerBucketObj, serviceBucketObj;
-
-      pendingRouterLookups.ExtractStatus(pendingRouterObj);
-      pendingIntrosetLookups.ExtractStatus(pendingIntrosetObj);
-      pendingTagLookups.ExtractStatus(pendingTagObj);
-      pendingExploreLookups.ExtractStatus(pendingExploreObj);
-      nodes->ExtractStatus(routerBucketObj);
-      services->ExtractStatus(serviceBucketObj);
-
-      obj.PutObject("pendingRouterLookups", pendingRouterObj);
-      obj.PutObject("pendingIntrosetLookups", pendingIntrosetObj);
-      obj.PutObject("pendingTagLookups", pendingTagObj);
-      obj.PutObject("pendingExploreLookups", pendingExploreObj);
-      obj.PutObject("nodes", routerBucketObj);
-      obj.PutObject("services", serviceBucketObj);
-      obj.PutString("ourKey", ourKey.ToHex());
+      util::StatusObject obj{
+          {"pendingRouterLookups", pendingRouterLookups.ExtractStatus()},
+          {"pendingIntrosetLookups", pendingIntrosetLookups.ExtractStatus()},
+          {"pendingTagLookups", pendingTagLookups.ExtractStatus()},
+          {"pendingExploreLookups", pendingExploreLookups.ExtractStatus()},
+          {"nodes", nodes->ExtractStatus()},
+          {"services", services->ExtractStatus()},
+          {"ourKey", ourKey.ToHex()}};
+      return obj;
     }
 
     void

llarp/dht/context.hpp

@@ -77,8 +77,8 @@ namespace llarp
       {
       }
 
-      void
-      ExtractStatus(util::StatusObject& obj) const override;
+      util::StatusObject
+      ExtractStatus() const override;
 
       llarp::Crypto*
       Crypto() const override;

llarp/dht/explorenetworkjob.hpp

@@ -31,29 +31,6 @@ namespace llarp
         return false;
       }
 
-      void
-      ExtractStatus(util::StatusObject &obj) const override
-      {
-        std::vector< std::string > foundObjs;
-        for(const auto &found : valuesFound)
-        {
-          foundObjs.emplace_back(found.ToHex());
-        }
-        obj.PutStringArray("found", foundObjs);
-
-        util::StatusObject txownerObj;
-        txownerObj.PutInt("txid", whoasked.txid);
-        txownerObj.PutString("node", whoasked.node.ToHex());
-        obj.PutObject("whoasked", txownerObj);
-
-        std::vector< std::string > asked;
-        for(const auto &peer : peersAsked)
-          asked.emplace_back(peer.ToHex());
-        obj.PutStringArray("asked", asked);
-
-        obj.PutString("target", target.ToHex());
-      }
-
       void
       DoNextRequest(const Key_t &) override
       {

llarp/dht/node.hpp

@@ -23,10 +23,10 @@ namespace llarp
       {
       }
 
-      void
-      ExtractStatus(util::StatusObject& obj) const override
+      util::StatusObject
+      ExtractStatus() const override
       {
-        obj.PutInt("lastUpdated", rc.last_updated);
+        return rc.ExtractStatus();
       }
 
       bool
@@ -52,22 +52,10 @@ namespace llarp
         introset.A.CalculateAddress(ID.as_array());
       }
 
-      void
-      ExtractStatus(util::StatusObject& obj) const override
+      util::StatusObject
+      ExtractStatus() const override
       {
-        obj.PutInt("timestamp", introset.T);
-
-        std::vector< util::StatusObject > introsObjs(introset.I.size());
-        size_t idx = 0;
-        for(const auto intro : introset.I)
-        {
-          auto& introObj = introsObjs[idx++];
-          introObj.PutString("router", intro.router.ToHex());
-          introObj.PutInt("expiresAt", intro.expiresAt);
-          introObj.PutInt("latency", intro.latency);
-          introObj.PutInt("version", intro.version);
-        }
-        obj.PutObjectArray("intros", introsObjs);
+        return introset.ExtractStatus();
       }
 
       bool

llarp/dht/publishservicejob.cpp

@@ -31,26 +31,6 @@ namespace llarp
       return true;
     }
 
-    void
-    PublishServiceJob::ExtractStatus(util::StatusObject &obj) const
-    {
-      obj.PutString("target", I.A.Name());
-      obj.PutInt("S", S);
-      util::StatusObject introsetObj;
-      I.ExtractStatus(introsetObj);
-      obj.PutObject("introset", introsetObj);
-      std::vector< std::string > dontTellObj;
-      for(const auto &key : dontTell)
-        dontTellObj.emplace_back(key.ToHex());
-      obj.PutStringArray("exclude", dontTellObj);
-
-      util::StatusObject whoaskedTx;
-      whoaskedTx.PutInt("txid", whoasked.txid);
-      whoaskedTx.PutString("node", whoasked.node.ToHex());
-
-      obj.PutObject("whoasked", whoaskedTx);
-    }
-
     void
     PublishServiceJob::Start(const TXOwner &peer)
     {

llarp/dht/publishservicejob.hpp

@@ -34,9 +34,6 @@ namespace llarp
         return false;
       }
 
-      void
-      ExtractStatus(util::StatusObject &obj) const override;
-
       void
       DoNextRequest(const Key_t &) override
       {

llarp/dht/recursiverouterlookup.hpp

@@ -25,33 +25,6 @@ namespace llarp
         return false;
       }
 
-      void
-      ExtractStatus(util::StatusObject &obj) const override
-      {
-        std::vector< util::StatusObject > foundObjs(valuesFound.size());
-        {
-          size_t idx = 0;
-          for(const auto &found : valuesFound)
-          {
-            util::StatusObject &foundObj = foundObjs[idx++];
-            found.ExtractStatus(foundObj);
-          }
-        }
-        obj.PutObjectArray("found", foundObjs);
-
-        util::StatusObject txownerObj;
-        txownerObj.PutInt("txid", whoasked.txid);
-        txownerObj.PutString("node", whoasked.node.ToHex());
-        obj.PutObject("whoasked", txownerObj);
-
-        std::vector< std::string > asked;
-        for(const auto &peer : peersAsked)
-          asked.emplace_back(peer.ToHex());
-        obj.PutStringArray("asked", asked);
-
-        obj.PutString("target", target.ToHex());
-      }
-
       void
       DoNextRequest(const Key_t &) override
       {

llarp/dht/serviceaddresslookup.cpp

@@ -72,32 +72,6 @@ namespace llarp
                                         ask);
       }
     }
-    void
-    ServiceAddressLookup::ExtractStatus(util::StatusObject &obj) const
-    {
-      std::vector< util::StatusObject > foundObjs(valuesFound.size());
-      {
-        size_t idx = 0;
-        for(const auto &found : valuesFound)
-        {
-          util::StatusObject &introsetObj = foundObjs[idx++];
-          found.ExtractStatus(introsetObj);
-        }
-      }
-      obj.PutObjectArray("found", foundObjs);
-
-      util::StatusObject txownerObj;
-      txownerObj.PutInt("txid", whoasked.txid);
-      txownerObj.PutString("node", whoasked.node.ToHex());
-      obj.PutObject("whoasked", txownerObj);
-
-      std::vector< std::string > asked;
-      for(const auto &peer : peersAsked)
-        asked.emplace_back(peer.ToHex());
-      obj.PutStringArray("asked", asked);
-
-      obj.PutString("target", target.ToHex());
-    }
 
     void
     ServiceAddressLookup::SendReply()

llarp/dht/serviceaddresslookup.hpp

@@ -34,9 +34,6 @@ namespace llarp
       void
       DoNextRequest(const Key_t &ask) override;
 
-      void
-      ExtractStatus(util::StatusObject &obj) const override;
-
       virtual void
       SendReply() override;
     };

llarp/dht/taglookup.cpp

@@ -30,32 +30,6 @@ namespace llarp
                         new FindIntroMessage(target, peer.txid, R));
     }
 
-    void
-    TagLookup::ExtractStatus(util::StatusObject &obj) const
-    {
-      std::vector< util::StatusObject > foundObjs(valuesFound.size());
-      {
-        size_t idx = 0;
-        for(const auto &found : valuesFound)
-        {
-          util::StatusObject &introsetObj = foundObjs[idx++];
-          found.ExtractStatus(introsetObj);
-        }
-      }
-      obj.PutObjectArray("found", foundObjs);
-
-      util::StatusObject txownerObj;
-      txownerObj.PutInt("txid", whoasked.txid);
-      txownerObj.PutString("node", whoasked.node.ToHex());
-      obj.PutObject("whoasked", txownerObj);
-
-      std::vector< std::string > asked;
-      for(const auto &peer : peersAsked)
-        asked.emplace_back(peer.ToHex());
-      obj.PutStringArray("asked", asked);
-      obj.PutString("target", target.ToString());
-    }
-
     void
     TagLookup::SendReply()
     {

llarp/dht/taglookup.hpp

@@ -30,9 +30,6 @@ namespace llarp
         return false;
       }
 
-      void
-      ExtractStatus(util::StatusObject &obj) const override;
-
       void
       DoNextRequest(const Key_t &) override
       {

llarp/dht/tx.hpp

@@ -38,9 +38,25 @@ namespace llarp
       bool
       AskNextPeer(const Key_t& prevPeer, const std::unique_ptr< Key_t >& next);
 
-      virtual void
-      ExtractStatus(util::StatusObject&) const override
+      util::StatusObject
+      ExtractStatus() const override
       {
+        util::StatusObject obj{{"whoasked", whoasked.ExtractStatus()},
+                               {"target", target.ToHex()}};
+        std::vector< util::StatusObject > foundObjs;
+        std::transform(valuesFound.begin(), valuesFound.end(),
+                       std::back_inserter(foundObjs),
+                       [](const auto& item) -> util::StatusObject {
+                         return item.ExtractStatus();
+                       });
+
+        obj.Put("found", foundObjs);
+        std::vector< std::string > asked;
+        std::transform(
+            peersAsked.begin(), peersAsked.end(), std::back_inserter(asked),
+            [](const auto& item) -> std::string { return item.ToHex(); });
+        obj.Put("asked", asked);
+        return obj;
       }
 
       virtual bool

llarp/dht/txholder.hpp

@@ -29,56 +29,34 @@ namespace llarp
       const TX< K, V >*
       GetPendingLookupFrom(const TXOwner& owner) const;
 
-      void
-      ExtractStatus(util::StatusObject& obj) const override
+      util::StatusObject
+      ExtractStatus() const override
       {
-        std::vector< util::StatusObject > txObjs(tx.size());
-        std::vector< util::StatusObject > timeoutsObjs(timeouts.size());
-        std::vector< util::StatusObject > waitingObjs(waiting.size());
-        {
-          auto itr   = tx.begin();
-          size_t idx = 0;
-          while(itr != tx.end())
-          {
-            auto& txSuperObj = txObjs[idx++];
-            util::StatusObject txObj, txOwnerObj;
-            itr->second->ExtractStatus(txObj);
-            txOwnerObj.PutInt("txid", itr->first.txid);
-            txOwnerObj.PutString("node", itr->first.node.ToHex());
-
-            txSuperObj.PutObject("tx", txObj);
-            txSuperObj.PutObject("owner", txOwnerObj);
-            ++itr;
-          }
-        }
-        obj.PutObjectArray("tx", txObjs);
-        {
-          auto itr   = timeouts.begin();
-          size_t idx = 0;
-          while(itr != timeouts.end())
-          {
-            auto& timeoutObj = timeoutsObjs[idx++];
-            timeoutObj.PutInt("time", itr->second);
-            timeoutObj.PutString("target", itr->first.ToHex());
-            ++itr;
-          }
-        }
-        obj.PutObjectArray("timeouts", timeoutsObjs);
-        {
-          auto itr   = waiting.begin();
-          size_t idx = 0;
-          while(itr != waiting.end())
-          {
-            auto& waitingObj = waitingObjs[idx++];
-            util::StatusObject txOwnerObj;
-            txOwnerObj.PutInt("txid", itr->second.txid);
-            txOwnerObj.PutString("node", itr->second.node.ToHex());
-            waitingObj.PutObject("whoasked", txOwnerObj);
-            waitingObj.PutString("target", itr->first.ToHex());
-            ++itr;
-          }
-        }
-        obj.PutObjectArray("waiting", waitingObjs);
+        util::StatusObject obj{};
+        std::vector< util::StatusObject > txObjs, timeoutsObjs, waitingObjs;
+        std::transform(tx.begin(), tx.end(), std::back_inserter(txObjs),
+                       [](const auto& item) -> util::StatusObject {
+                         return util::StatusObject{
+                             {"owner", item.first.ExtractStatus()},
+                             {"tx", item.second->ExtractStatus()}};
+                       });
+        obj.Put("tx", txObjs);
+        std::transform(
+            timeouts.begin(), timeouts.end(), std::back_inserter(timeoutsObjs),
+            [](const auto& item) -> util::StatusObject {
+              return util::StatusObject{{"time", item.second},
+                                        {"target", item.first.ToHex()}};
+            });
+        obj.Put("timeouts", timeoutsObjs);
+        std::transform(waiting.begin(), waiting.end(),
+                       std::back_inserter(waitingObjs),
+                       [](const auto& item) -> util::StatusObject {
+                         return util::StatusObject{
+                             {"target", item.first.ToHex()},
+                             {"whoasked", item.second.ExtractStatus()}};
+                       });
+        obj.Put("waiting", waitingObjs);
+        return obj;
       }
 
       bool

llarp/dht/txowner.hpp

@@ -2,14 +2,14 @@
 #define LLARP_DHT_TXOWNER_HPP
 
 #include <dht/key.hpp>
-
+#include <util/status.hpp>
 #include <cstdint>
 
 namespace llarp
 {
   namespace dht
   {
-    struct TXOwner
+    struct TXOwner : public util::IStateful
     {
       Key_t node;
       uint64_t txid = 0;
@@ -25,6 +25,16 @@ namespace llarp
       {
       }
 
+      util::StatusObject
+      ExtractStatus() const override
+      {
+        util::StatusObject obj{
+            {"txid", txid},
+            {"node", node.ToHex()},
+        };
+        return obj;
+      }
+
       bool
       operator==(const TXOwner& other) const
       {

llarp/exit/context.cpp

@@ -46,17 +46,17 @@ namespace llarp
       }
     }
 
-    void
-    Context::ExtractStatus(util::StatusObject& obj) const
+    util::StatusObject
+    Context::ExtractStatus() const
     {
+      util::StatusObject obj{};
       auto itr = m_Exits.begin();
       while(itr != m_Exits.end())
       {
-        util::StatusObject sobj;
-        itr->second->ExtractStatus(sobj);
-        obj.PutObject(itr->first.c_str(), sobj);
+        obj.Put(itr->first, itr->second->ExtractStatus());
         ++itr;
       }
+      return obj;
     }
 
     void

llarp/exit/context.hpp

@@ -24,8 +24,8 @@ namespace llarp
       void
       ClearAllEndpoints();
 
-      void
-      ExtractStatus(util::StatusObject &obj) const;
+      util::StatusObject
+      ExtractStatus() const override;
 
       /// send close to all exit sessions and remove all sessions
       void

llarp/exit/endpoint.cpp

@@ -31,19 +31,20 @@ namespace llarp
       m_Parent->RemoveExit(this);
     }
 
-    void
-    Endpoint::ExtractStatus(util::StatusObject& obj) const
+    util::StatusObject
+    Endpoint::ExtractStatus() const
     {
-      obj.PutString("identity", m_remoteSignKey.ToHex());
-      obj.PutString("ip", m_IP.ToString());
-      obj.PutInt("txRate", m_TxRate);
-      obj.PutInt("rxRate", m_RxRate);
-      obj.PutInt("createdAt", createdAt);
       auto now = m_Parent->Now();
-      obj.PutBool("exiting", !m_RewriteSource);
-      obj.PutBool("looksDead", LooksDead(now));
-      obj.PutBool("expiresSoon", ExpiresSoon(now));
-      obj.PutBool("expired", IsExpired(now));
+      util::StatusObject obj{{"identity", m_remoteSignKey.ToString()},
+                             {"ip", m_IP.ToString()},
+                             {"txRate", m_TxRate},
+                             {"rxRate", m_RxRate},
+                             {"createdAt", createdAt},
+                             {"exiting", !m_RewriteSource},
+                             {"looksDead", LooksDead(now)},
+                             {"expiresSoon", ExpiresSoon(now)},
+                             {"expired", IsExpired(now)}};
+      return obj;
     }
 
     bool

llarp/exit/endpoint.hpp

@@ -32,8 +32,8 @@ namespace llarp
       Close();
 
       /// implement istateful
-      void
-      ExtractStatus(util::StatusObject& obj) const override;
+      util::StatusObject
+      ExtractStatus() const override;
 
       /// return true if we are expired right now
       bool

llarp/exit/session.cpp

@@ -24,13 +24,14 @@ namespace llarp
     {
     }
 
-    void
-    BaseSession::ExtractStatus(util::StatusObject& obj) const
+    util::StatusObject
+    BaseSession::ExtractStatus() const
     {
-      path::Builder::ExtractStatus(obj);
-      obj.PutInt("lastExitUse", m_LastUse);
+      auto obj = path::Builder::ExtractStatus();
+      obj.Put("lastExitUse", m_LastUse);
       auto pub = m_ExitIdentity.toPublic();
-      obj.PutString("exitIdentity", pub.ToString());
+      obj.Put("exitIdentity", pub.ToString());
+      return obj;
     }
 
     bool

llarp/exit/session.hpp

@@ -25,8 +25,8 @@ namespace llarp
 
       virtual ~BaseSession();
 
-      void
-      ExtractStatus(util::StatusObject& obj) const override;
+      util::StatusObject
+      ExtractStatus() const override;
 
       bool
       SelectHop(llarp_nodedb* db, const RouterContact& prev, RouterContact& cur,

llarp/handlers/exit.cpp

@@ -42,23 +42,18 @@ namespace llarp
     {
     }
 
-    void
-    ExitEndpoint::ExtractStatus(util::StatusObject &obj) const
+    util::StatusObject
+    ExitEndpoint::ExtractStatus() const
     {
-      obj.PutBool("permitExit", m_PermitExit);
-      std::vector< util::StatusObject > activeObjs(m_ActiveExits.size());
+      util::StatusObject obj{{"permitExit", m_PermitExit},
+                             {"ip", m_IfAddr.ToString()}};
+      util::StatusObject exitsObj{};
+      for(const auto &item : m_ActiveExits)
       {
-        size_t idx = 0;
-        auto itr   = m_ActiveExits.begin();
-        while(itr != m_ActiveExits.end())
-        {
-          util::StatusObject &sessionObj = activeObjs[idx++];
-          itr->second->ExtractStatus(sessionObj);
-          ++itr;
-        }
+        exitsObj.Put(item.first.ToHex(), item.second->ExtractStatus());
       }
-      obj.PutString("ip", m_IfAddr.ToString());
-      obj.PutObjectArray("exitSessions", activeObjs);
+      obj.Put("exits", exitsObj);
+      return obj;
     }
 
     bool

llarp/handlers/exit.hpp

@@ -25,8 +25,8 @@ namespace llarp
       std::string
       Name() const;
 
-      void
-      ExtractStatus(util::StatusObject& obj) const override;
+      util::StatusObject
+      ExtractStatus() const override;
 
       bool
       ShouldHookDNSMessage(const dns::Message& msg) const override;

llarp/handlers/tun.cpp

@@ -53,36 +53,36 @@ namespace llarp
       tunif.recvpkt      = &tunifRecvPkt;
     }
 
-    void
-    TunEndpoint::ExtractStatus(util::StatusObject &obj) const
+    util::StatusObject
+    TunEndpoint::ExtractStatus() const
     {
-      service::Endpoint::ExtractStatus(obj);
-      obj.PutString("ifaddr", m_OurRange.ToString());
+      auto obj = service::Endpoint::ExtractStatus();
+      obj.Put("ifaddr", m_OurRange.ToString());
 
       std::vector< std::string > resolvers;
       for(const auto &addr : m_UpstreamResolvers)
         resolvers.emplace_back(addr.ToString());
-      obj.PutStringArray("ustreamResolvers", resolvers);
-      obj.PutString("localResolver", m_LocalResolverAddr.ToString());
-      util::StatusObject ips;
+      obj.Put("ustreamResolvers", resolvers);
+      obj.Put("localResolver", m_LocalResolverAddr.ToString());
+      util::StatusObject ips{};
       for(const auto &item : m_IPActivity)
       {
-        util::StatusObject ipObj;
-        ipObj.PutInt("lastActive", item.second);
+        util::StatusObject ipObj{{"lastActive", item.second}};
         std::string remoteStr;
         AlignedBuffer< 32 > addr = m_IPToAddr.at(item.first);
         if(m_SNodes.at(addr))
           remoteStr = RouterID(addr.as_array()).ToString();
         else
           remoteStr = service::Address(addr.as_array()).ToString();
-        ipObj.PutString("remote", remoteStr);
+        ipObj.Put("remote", remoteStr);
         std::string ipaddr = item.first.ToString();
-        ips.PutObject(ipaddr.c_str(), ipObj);
+        ips.Put(ipaddr.c_str(), ipObj);
       }
-      obj.PutObject("addrs", ips);
-      obj.PutString("ourIP", m_OurIP.ToString());
-      obj.PutString("nextIP", m_NextIP.ToString());
-      obj.PutString("maxIP", m_MaxIP.ToString());
+      obj.Put("addrs", ips);
+      obj.Put("ourIP", m_OurIP.ToString());
+      obj.Put("nextIP", m_NextIP.ToString());
+      obj.Put("maxIP", m_MaxIP.ToString());
+      return obj;
     }
 
     bool

llarp/handlers/tun.hpp

@@ -30,8 +30,8 @@ namespace llarp
       virtual void
       Tick(llarp_time_t now) override;
 
-      void
-      ExtractStatus(util::StatusObject& obj) const override;
+      util::StatusObject
+      ExtractStatus() const override;
 
       bool
       ShouldHookDNSMessage(const dns::Message& msg) const override;

llarp/path/path.cpp

@@ -435,55 +435,57 @@ namespace llarp
       _status = st;
     }
 
-    void
-    Path::ExtractStatus(util::StatusObject& obj) const
+    util::StatusObject
+    PathHopConfig::ExtractStatus() const
     {
-      std::vector< util::StatusObject > subobj(hops.size());
-      {
-        size_t idx = 0;
-        for(const auto& hop : hops)
-        {
-          util::StatusObject& hopobj = subobj[idx++];
-          hopobj.PutString("txid", hop.txID.ToHex());
-          hopobj.PutString("rxid", hop.rxID.ToHex());
-          hopobj.PutString("router", hop.rc.pubkey.ToString());
-          hopobj.PutInt("lifetime", hop.lifetime);
-        }
-      }
-      obj.PutObjectArray("hops", subobj);
+      util::StatusObject obj{{"lifetime", lifetime},
+                             {"router", rc.pubkey.ToHex()},
+                             {"txid", txID.ToHex()},
+                             {"rxid", rxID.ToHex()}};
+      return obj;
+    }
 
-      util::StatusObject introObj;
-      intro.ExtractStatus(introObj);
-      obj.PutObject("intro", introObj);
+    util::StatusObject
+    Path::ExtractStatus() const
+    {
+      auto now = llarp::time_now_ms();
+
+      util::StatusObject obj{{"intro", intro.ExtractStatus()},
+                             {"lastRecvMsg", m_LastRecvMessage},
+                             {"lastLatencyTest", m_LastLatencyTestTime},
+                             {"buildStarted", buildStarted},
+                             {"expired", Expired(now)},
+                             {"expiresSoon", ExpiresSoon(now)},
+                             {"expiresAt", ExpireTime()},
+                             {"ready", IsReady()},
+                             {"hasExit", SupportsAnyRoles(ePathRoleExit)}};
+
+      std::vector< util::StatusObject > hopsObj;
+      std::transform(hops.begin(), hops.end(), std::back_inserter(hopsObj),
+                     [](const auto& hop) -> util::StatusObject {
+                       return hop.ExtractStatus();
+                     });
+      obj.Put("hops", hopsObj);
 
       switch(_status)
       {
         case ePathBuilding:
-          obj.PutString("status", "building");
+          obj.Put("status", "building");
           break;
         case ePathEstablished:
-          obj.PutString("status", "established");
+          obj.Put("status", "established");
           break;
         case ePathTimeout:
-          obj.PutString("status", "timeout");
+          obj.Put("status", "timeout");
           break;
         case ePathExpired:
-          obj.PutString("status", "expired");
+          obj.Put("status", "expired");
           break;
         default:
-          obj.PutString("status", "unknown");
+          obj.Put("status", "unknown");
           break;
       }
-      obj.PutInt("lastRecvMsg", m_LastRecvMessage);
-      obj.PutInt("lastLatencyTest", m_LastLatencyTestTime);
-      obj.PutInt("buildStarted", buildStarted);
-      obj.PutBool("ready", IsReady());
-      obj.PutBool("hasExit", SupportsAnyRoles(ePathRoleExit));
-
-      auto now = llarp::time_now_ms();
-      obj.PutBool("expired", Expired(now));
-      obj.PutBool("expiresSoon", ExpiresSoon(now));
-      obj.PutInt("expiresAt", ExpireTime());
+      return obj;
     }
 
     void

llarp/path/path.hpp

@@ -267,7 +267,7 @@ namespace llarp
     };
 
     /// configuration for a single hop when building a path
-    struct PathHopConfig
+    struct PathHopConfig : public util::IStateful
     {
       /// path id
       PathID_t txID, rxID;
@@ -288,6 +288,9 @@ namespace llarp
 
       ~PathHopConfig();
       PathHopConfig();
+
+      util::StatusObject
+      ExtractStatus() const override;
     };
 
     /// A path we made
@@ -320,8 +323,8 @@ namespace llarp
       Path(const std::vector< RouterContact >& routers, PathSet* parent,
            PathRole startingRoles);
 
-      void
-      ExtractStatus(util::StatusObject& obj) const override;
+      util::StatusObject
+      ExtractStatus() const override;
 
       PathRole
       Role() const

llarp/path/pathbuilder.cpp

@@ -184,24 +184,20 @@ namespace llarp
       router->paths.RemovePathBuilder(this);
     }
 
-    void
-    Builder::ExtractStatus(util::StatusObject& obj) const
+    util::StatusObject
+    Builder::ExtractStatus() const
     {
-      obj.PutInt("keygens", keygens.load());
-      obj.PutInt("numHops", numHops);
-      obj.PutInt("numPaths", m_NumPaths);
-      std::vector< util::StatusObject > pathObjs(m_Paths.size());
-      {
-        size_t idx = 0;
-        auto itr   = m_Paths.begin();
-        while(itr != m_Paths.end())
-        {
-          util::StatusObject& pobj = pathObjs[idx++];
-          itr->second->ExtractStatus(pobj);
-          ++itr;
-        }
-      }
-      obj.PutObjectArray("paths", pathObjs);
+      util::StatusObject obj{{"keygens", uint64_t(keygens.load())},
+                             {"numHops", uint64_t(numHops)},
+                             {"numPaths", uint64_t(m_NumPaths)}};
+      std::vector< util::StatusObject > pathObjs;
+      std::transform(m_Paths.begin(), m_Paths.end(),
+                     std::back_inserter(pathObjs),
+                     [](const auto& item) -> util::StatusObject {
+                       return item.second->ExtractStatus();
+                     });
+      obj.Put("paths", pathObjs);
+      return obj;
     }
 
     bool

llarp/path/pathbuilder.hpp

@@ -38,8 +38,8 @@ namespace llarp
 
       virtual ~Builder();
 
-      virtual void
-      ExtractStatus(util::StatusObject& obj) const override;
+      virtual util::StatusObject
+      ExtractStatus() const override;
 
       virtual bool
       SelectHop(llarp_nodedb* db, const RouterContact& prev, RouterContact& cur,

llarp/router/router.cpp

@@ -237,16 +237,13 @@ namespace llarp
     llarp_dht_context_free(_dht);
   }
 
-  void
-  Router::ExtractStatus(util::StatusObject &obj) const
-  {
-    util::StatusObject dhtObj, exitObj, hsObj;
-    _dht->impl.ExtractStatus(dhtObj);
-    obj.PutObject("dht", dhtObj);
-    hiddenServiceContext.ExtractStatus(hsObj);
-    obj.PutObject("services", hsObj);
-    exitContext.ExtractStatus(exitObj);
-    obj.PutObject("exit", exitObj);
+  util::StatusObject
+  Router::ExtractStatus() const
+  {
+    util::StatusObject obj{{"dht", _dht->impl.ExtractStatus()},
+                           {"services", hiddenServiceContext.ExtractStatus()},
+                           {"exit", exitContext.ExtractStatus()}};
+    return obj;
   }
 
   bool

llarp/router/router.hpp

@@ -153,8 +153,8 @@ namespace llarp
       return _dht;
     }
 
-    void
-    ExtractStatus(util::StatusObject &obj) const override;
+    util::StatusObject
+    ExtractStatus() const override;
 
     Crypto *
     crypto() const override

llarp/router_contact.cpp

@@ -151,14 +151,16 @@ namespace llarp
     last_updated = 0;
   }
 
-  void
-  RouterContact::ExtractStatus(util::StatusObject &obj) const
+  util::StatusObject
+  RouterContact::ExtractStatus() const
   {
-    obj.PutInt("lastUpdated", last_updated);
-    obj.PutBool("exit", IsExit());
-    obj.PutBool("publicRouter", IsPublicRouter());
+    util::StatusObject obj{{"lastUpdated", last_updated},
+                           {"exit", IsExit()},
+                           {"publicRouter", IsPublicRouter()},
+                           {"identity", pubkey.ToHex()}};
     if(HasNick())
-      obj.PutString("nickname", Nick());
+      obj.Put("nickname", Nick());
+    return obj;
   }
 
   bool

llarp/router_contact.hpp

@@ -99,8 +99,8 @@ namespace llarp
 
     uint64_t last_updated = 0;
 
-    void
-    ExtractStatus(util::StatusObject &obj) const override;
+    util::StatusObject
+    ExtractStatus() const override;
 
     bool
     BEncode(llarp_buffer_t *buf) const override;

llarp/router_id.cpp

@@ -9,6 +9,13 @@ namespace llarp
     return std::string(llarp::Base32Encode(*this, stack)) + ".snode";
   }
 
+  util::StatusObject
+  RouterID::ExtractStatus() const
+  {
+    util::StatusObject obj{{"snode", ToString()}, {"hex", ToHex()}};
+    return obj;
+  }
+
   bool
   RouterID::FromString(const std::string& str)
   {

llarp/router_id.hpp

@@ -2,10 +2,11 @@
 #define LLARP_ROUTER_ID_HPP
 
 #include <util/aligned.hpp>
+#include <util/status.hpp>
 
 namespace llarp
 {
-  struct RouterID : public AlignedBuffer< 32 >
+  struct RouterID : public AlignedBuffer< 32 >, public util::IStateful
   {
     static constexpr size_t SIZE = 32;
 
@@ -23,6 +24,9 @@ namespace llarp
     {
     }
 
+    util::StatusObject
+    ExtractStatus() const override;
+
     std::string
     ToString() const;
 

llarp/rpc/rpc.cpp

@@ -220,12 +220,8 @@ namespace llarp
       bool
       DumpState(Response& resp) const
       {
-        util::StatusObject dump;
-        router->ExtractStatus(dump);
-        if(!dump.Impl.IsObject())
-          return false;
+        util::StatusObject dump = router->ExtractStatus();
         dump.Impl.Accept(resp);
-
         return true;
       }
 

llarp/service/Intro.cpp

@@ -8,13 +8,14 @@ namespace llarp
     {
     }
 
-    void
-    Introduction::ExtractStatus(util::StatusObject& obj) const
+    util::StatusObject
+    Introduction::ExtractStatus() const
     {
-      obj.PutString("router", router.ToHex());
-      obj.PutInt("expiresAt", expiresAt);
-      obj.PutInt("latency", latency);
-      obj.PutInt("version", version);
+      util::StatusObject obj{{"router", router.ToHex()},
+                             {"expiresAt", expiresAt},
+                             {"latency", latency},
+                             {"version", uint64_t(version)}};
+      return obj;
     }
 
     bool

llarp/service/Intro.hpp

@@ -31,8 +31,8 @@ namespace llarp
         expiresAt = other.expiresAt;
       }
 
-      void
-      ExtractStatus(util::StatusObject& obj) const override;
+      util::StatusObject
+      ExtractStatus() const override;
 
       bool
       IsExpired(llarp_time_t now) const

llarp/service/IntroSet.cpp

@@ -12,22 +12,19 @@ namespace llarp
         delete W;
     }
 
-    void
-    IntroSet::ExtractStatus(util::StatusObject& obj) const
+    util::StatusObject
+    IntroSet::ExtractStatus() const
     {
-      std::vector< util::StatusObject > introsObjs(I.size());
-      {
-        size_t idx = 0;
-        for(const auto& intro : I)
-        {
-          util::StatusObject& introObj = introsObjs[idx++];
-          intro.ExtractStatus(introObj);
-        }
-      }
-      obj.PutObjectArray("intros", introsObjs);
+      util::StatusObject obj{{"published", T}};
+      std::vector< util::StatusObject > introsObjs;
+      std::transform(I.begin(), I.end(), std::back_inserter(introsObjs),
+                     [](const auto& intro) -> util::StatusObject {
+                       return intro.ExtractStatus();
+                     });
+      obj.Put("intros", introsObjs);
       if(!topic.IsZero())
-        obj.PutString("topic", topic.ToString());
-      obj.PutInt("published", T);
+        obj.Put("topic", topic.ToString());
+      return obj;
     }
 
     bool

llarp/service/IntroSet.hpp

@@ -27,8 +27,8 @@ namespace llarp
     struct IntroSet final : public llarp::IBEncodeMessage,
                             public util::IStateful
     {
-      void
-      ExtractStatus(util::StatusObject& obj) const override;
+      util::StatusObject
+      ExtractStatus() const override;
 
       ServiceInfo A;
       std::vector< Introduction > I;

llarp/service/context.cpp

@@ -30,17 +30,17 @@ namespace llarp
       return true;
     }
 
-    void
-    Context::ExtractStatus(util::StatusObject &obj) const
+    util::StatusObject
+    Context::ExtractStatus() const
     {
+      util::StatusObject obj{};
       auto itr = m_Endpoints.begin();
       while(itr != m_Endpoints.end())
       {
-        util::StatusObject sobj;
-        itr->second->ExtractStatus(sobj);
-        obj.PutObject(itr->first.c_str(), sobj);
+        obj.Put(itr->first, itr->second->ExtractStatus());
         ++itr;
       }
+      return obj;
     }
 
     void

llarp/service/context.hpp

@@ -25,8 +25,8 @@ namespace llarp
       bool
       StopAll();
 
-      void
-      ExtractStatus(util::StatusObject &obj) const override;
+      util::StatusObject
+      ExtractStatus() const override;
 
       bool
       hasEndpoints();

llarp/service/endpoint.cpp

@@ -144,84 +144,44 @@ namespace llarp
       }
     }
 
-    void
-    Endpoint::ExtractStatus(util::StatusObject& obj) const
+    util::StatusObject
+    Endpoint::ExtractStatus() const
     {
-      path::Builder::ExtractStatus(obj);
-      obj.PutString("identity", m_Identity.pub.Addr().ToString());
+      auto obj = path::Builder::ExtractStatus();
+      obj.Put("identity", m_Identity.pub.Addr().ToString());
 
-      obj.PutInt("lastPublished", m_LastPublish);
-      obj.PutInt("lastPublishAttempt", m_LastPublishAttempt);
-      util::StatusObject introsetObj;
-      m_IntroSet.ExtractStatus(introsetObj);
-      obj.PutObject("introset", introsetObj);
+      obj.Put("lastPublished", m_LastPublish);
+      obj.Put("lastPublishAttempt", m_LastPublishAttempt);
+      obj.Put("introset", m_IntroSet.ExtractStatus());
 
       if(!m_Tag.IsZero())
-        obj.PutString("tag", m_Tag.ToString());
+        obj.Put("tag", m_Tag.ToString());
 
-      std::vector< util::StatusObject > remoteSessions(m_RemoteSessions.size());
-      std::vector< util::StatusObject > deadSessions(m_DeadSessions.size());
-      std::vector< util::StatusObject > snodeSessions(m_SNodeSessions.size());
-      std::vector< util::StatusObject > lookups(m_PendingLookups.size());
+      auto putContainer = [](util::StatusObject& o, const std::string& keyname,
+                             const auto& container) {
+        std::vector< util::StatusObject > objs;
+        std::transform(container.begin(), container.end(),
+                       std::back_inserter(objs),
+                       [](const auto& item) -> util::StatusObject {
+                         return item.second->ExtractStatus();
+                       });
+        o.Put(keyname, objs);
+      };
+      putContainer(obj, "deadSessions", m_DeadSessions);
+      putContainer(obj, "remoteSessions", m_RemoteSessions);
+      putContainer(obj, "snodeSessions", m_SNodeSessions);
+      putContainer(obj, "lookups", m_PendingLookups);
 
-      {
-        size_t idx = 0;
-        auto itr   = m_RemoteSessions.begin();
-        while(itr != m_RemoteSessions.end())
-        {
-          util::StatusObject& sobj = remoteSessions[idx++];
-          itr->second->ExtractStatus(sobj);
-          ++itr;
-        }
-      }
-      obj.PutObjectArray("remoteSessions", remoteSessions);
-      {
-        size_t idx = 0;
-        auto itr   = m_DeadSessions.begin();
-        while(itr != m_DeadSessions.end())
-        {
-          util::StatusObject& sobj = deadSessions[idx++];
-          itr->second->ExtractStatus(sobj);
-          ++itr;
-        }
-      }
-      obj.PutObjectArray("deadSessions", deadSessions);
-      {
-        size_t idx = 0;
-        auto itr   = m_SNodeSessions.begin();
-        while(itr != m_SNodeSessions.end())
-        {
-          util::StatusObject& sobj = snodeSessions[idx++];
-          itr->second->ExtractStatus(sobj);
-          ++itr;
-        }
-      }
-      obj.PutObjectArray("snodeSessions", snodeSessions);
-      {
-        size_t idx = 0;
-        auto itr   = m_PendingLookups.begin();
-        while(itr != m_PendingLookups.end())
-        {
-          util::StatusObject& sobj = lookups[idx++];
-          itr->second->ExtractStatus(sobj);
-          ++itr;
-        }
-      }
-      obj.PutObjectArray("lookups", lookups);
+      util::StatusObject sessionObj{};
 
-      util::StatusObject sessionObj;
+      for(const auto& item : m_Sessions)
       {
-        auto itr = m_Sessions.begin();
-        while(itr != m_Sessions.end())
-        {
-          util::StatusObject sobj;
-          itr->second.ExtractStatus(sobj);
-          std::string k = itr->first.ToHex();
-          sessionObj.PutObject(k.c_str(), sobj);
-          ++itr;
-        }
+        std::string k = item.first.ToHex();
+        sessionObj.Put(k, item.second.ExtractStatus());
       }
-      obj.PutObject("converstations", sessionObj);
+
+      obj.Put("converstations", sessionObj);
+      return obj;
     }
 
     void
@@ -1718,38 +1678,31 @@ namespace llarp
       }
     }
 
-    void
-    Endpoint::OutboundContext::ExtractStatus(util::StatusObject& obj) const
-    {
-      path::Builder::ExtractStatus(obj);
-      obj.PutString("currentConvoTag", currentConvoTag.ToHex());
-      util::StatusObject remoteIntroObj;
-      remoteIntro.ExtractStatus(remoteIntroObj);
-      obj.PutObject("remoteIntro", remoteIntroObj);
-      obj.PutInt("sessionCreatedAt", createdAt);
-      obj.PutInt("lastGoodSend", lastGoodSend);
-      obj.PutInt("seqno", sequenceNo);
-      obj.PutBool("markedBad", markedBad);
-      obj.PutInt("lastShift", lastShift);
-      obj.PutString("remoteIdentity", remoteIdent.Addr().ToString());
-      util::StatusObject remoteIntrosetObj;
-      currentIntroSet.ExtractStatus(remoteIntrosetObj);
-      obj.PutObject("currentRemoteIntroset", remoteIntrosetObj);
-      util::StatusObject nextIntroObj;
-      m_NextIntro.ExtractStatus(nextIntroObj);
-      obj.PutObject("nextIntro", nextIntroObj);
-      std::vector< util::StatusObject > badIntrosObj(m_BadIntros.size());
-      {
-        size_t idx = 0;
-        for(const auto& item : m_BadIntros)
-        {
-          auto& badIntroObj = badIntrosObj[idx++];
-          badIntroObj.PutInt("count", item.second);
-          util::StatusObject i;
-          item.first.ExtractStatus(i);
-          badIntroObj.PutObject("intro", i);
-        }
-      }
+    util::StatusObject
+    Endpoint::OutboundContext::ExtractStatus() const
+    {
+      auto obj = path::Builder::ExtractStatus();
+      obj.Put("currentConvoTag", currentConvoTag.ToHex());
+      obj.Put("remoteIntro", remoteIntro.ExtractStatus());
+      obj.Put("sessionCreatedAt", createdAt);
+      obj.Put("lastGoodSend", lastGoodSend);
+      obj.Put("seqno", sequenceNo);
+      obj.Put("markedBad", markedBad);
+      obj.Put("lastShift", lastShift);
+      obj.Put("remoteIdentity", remoteIdent.Addr().ToString());
+      obj.Put("currentRemoteIntroset", currentIntroSet.ExtractStatus());
+      obj.Put("nextIntro", m_NextIntro.ExtractStatus());
+      std::vector< util::StatusObject > badIntrosObj;
+      std::transform(m_BadIntros.begin(), m_BadIntros.end(),
+                     std::back_inserter(badIntrosObj),
+                     [](const auto& item) -> util::StatusObject {
+                       util::StatusObject o{
+                           {"count", item.second},
+                           {"intro", item.first.ExtractStatus()}};
+                       return o;
+                     });
+      obj.Put("badIntros", badIntrosObj);
+      return obj;
     }
 
     bool

llarp/service/endpoint.hpp

@@ -40,8 +40,8 @@ namespace llarp
       Endpoint(const std::string& nickname, llarp::Router* r, Context* parent);
       ~Endpoint();
 
-      virtual void
-      ExtractStatus(util::StatusObject& obj) const override;
+      virtual util::StatusObject
+      ExtractStatus() const override;
 
       void
       SetHandler(IDataHandler* h);
@@ -267,8 +267,8 @@ namespace llarp
         OutboundContext(const IntroSet& introSet, Endpoint* parent);
         ~OutboundContext();
 
-        void
-        ExtractStatus(util::StatusObject& obj) const override;
+        util::StatusObject
+        ExtractStatus() const override;
 
         bool
         Stop() override;
@@ -546,15 +546,14 @@ namespace llarp
         llarp_time_t lastUsed = 0;
         uint64_t seqno        = 0;
 
-        void
-        ExtractStatus(util::StatusObject& obj) const override
+        util::StatusObject
+        ExtractStatus() const override
         {
-          obj.PutInt("lastUsed", lastUsed);
-          obj.PutString("remote", remote.Addr().ToString());
-          obj.PutInt("seqno", seqno);
-          util::StatusObject introObj;
-          intro.ExtractStatus(introObj);
-          obj.PutObject("intro", introObj);
+          util::StatusObject obj{{"lastUsed", lastUsed},
+                                 {"remote", remote.Addr().ToString()},
+                                 {"seqno", seqno}};
+          obj.Put("intro", intro.ExtractStatus());
+          return obj;
         };
 
         bool

llarp/service/lookup.hpp

@@ -55,15 +55,16 @@ namespace llarp
       const std::string name;
       RouterID endpoint;
 
-      void
-      ExtractStatus(util::StatusObject& obj) const override
+      util::StatusObject
+      ExtractStatus() const override
       {
         auto now = llarp::time_now_ms();
-        obj.PutInt("txid", txid);
-        obj.PutString("endpoint", endpoint.ToHex());
-        obj.PutString("name", name);
-        obj.PutBool("timedOut", IsTimedOut(now));
-        obj.PutInt("createdAt", m_created);
+        util::StatusObject obj{{"txid", txid},
+                               {"endpoint", endpoint.ToHex()},
+                               {"name", name},
+                               {"timedOut", IsTimedOut(now)},
+                               {"createdAt", m_created}};
+        return obj;
       }
 
      protected:

llarp/service/tag.hpp

@@ -3,6 +3,7 @@
 
 #include <dht/key.hpp>
 #include <util/aligned.hpp>
+#include <util/status.hpp>
 
 #include <sodium/crypto_generichash.h>
 
@@ -14,7 +15,7 @@ namespace llarp
 {
   namespace service
   {
-    struct Tag : public llarp::AlignedBuffer< 16 >
+    struct Tag : public llarp::AlignedBuffer< 16 >, public util::IStateful
     {
       Tag() : llarp::AlignedBuffer< SIZE >()
       {
@@ -52,6 +53,12 @@ namespace llarp
         return *this;
       }
 
+      util::StatusObject
+      ExtractStatus() const override
+      {
+        return util::StatusObject{{"name", ToString()}};
+      }
+
       std::string
       ToString() const;
 

llarp/util/status.cpp

@@ -4,10 +4,14 @@ namespace llarp
 {
   namespace util
   {
-    StatusObject::StatusObject()
+    StatusObject::StatusObject(const StatusObject& other)
     {
 #ifdef USE_ABYSS
       Impl.SetObject();
+      auto& a = Impl.GetAllocator();
+      Impl.CopyFrom(other.Impl, a);
+#else
+      (void)other;
 #endif
     }
 
@@ -19,13 +23,37 @@ namespace llarp
     }
 
     void
-    StatusObject::PutBool(const char* name, bool val)
+    StatusObject::Put(const value_type& val)
+    {
+      Put(std::get< 0 >(val), std::get< 1 >(val));
+    }
+
+    void
+    StatusObject::Put(String_t name, const Variant& val)
+    {
+      if(absl::holds_alternative< uint64_t >(val))
+        PutInt(name, absl::get< uint64_t >(val));
+      else if(absl::holds_alternative< std::string >(val))
+        PutString(name, absl::get< std::string >(val));
+      else if(absl::holds_alternative< bool >(val))
+        PutBool(name, absl::get< bool >(val));
+      else if(absl::holds_alternative< StatusObject >(val))
+        PutObject(name, absl::get< StatusObject >(val));
+      else if(absl::holds_alternative< std::vector< std::string > >(val))
+        PutStringArray(name, absl::get< std::vector< std::string > >(val));
+      else if(absl::holds_alternative< std::vector< StatusObject > >(val))
+        PutObjectArray(name, absl::get< std::vector< StatusObject > >(val));
+    }
+
+    void
+    StatusObject::PutBool(String_t name, bool val)
     {
 #ifdef USE_ABYSS
       auto& a = Impl.GetAllocator();
       Value_t v;
       v.SetBool(val);
-      Value_t k(name, a);
+      auto s = llarp::string_view_string(name);
+      Value_t k(s.c_str(), a);
       Impl.AddMember(k, v, a);
 #else
       (void)name;
@@ -34,13 +62,14 @@ namespace llarp
     }
 
     void
-    StatusObject::PutInt(const char* name, uint64_t val)
+    StatusObject::PutInt(String_t name, uint64_t val)
     {
 #ifdef USE_ABYSS
       auto& a = Impl.GetAllocator();
       Value_t v;
       v.SetUint64(val);
-      Value_t k(name, a);
+      auto s = llarp::string_view_string(name);
+      Value_t k(s.c_str(), a);
       Impl.AddMember(k, v, a);
 #else
       (void)name;
@@ -49,14 +78,15 @@ namespace llarp
     }
 
     void
-    StatusObject::PutObject(const char* name, StatusObject& val)
+    StatusObject::PutObject(String_t name, const StatusObject& val)
     {
 #ifdef USE_ABYSS
       auto& a = Impl.GetAllocator();
       Value_t v;
       v.SetObject();
       v.CopyFrom(val.Impl, a);
-      Value_t k(name, a);
+      auto s = llarp::string_view_string(name);
+      Value_t k(s.c_str(), a);
       Impl.AddMember(k, v, a);
 #else
       (void)name;
@@ -65,8 +95,8 @@ namespace llarp
     }
 
     void
-    StatusObject::PutObjectArray(const char* name,
-                                 std::vector< StatusObject >& arr)
+    StatusObject::PutObjectArray(String_t name,
+                                 const std::vector< StatusObject >& arr)
     {
 #ifdef USE_ABYSS
       auto& a = Impl.GetAllocator();
@@ -77,8 +107,8 @@ namespace llarp
       {
         v.PushBack(i.SetObject().CopyFrom(obj.Impl, a), a);
       }
-      Value_t k(name, a);
-
+      auto s = llarp::string_view_string(name);
+      Value_t k(s.c_str(), a);
       Impl.AddMember(k, v, a);
 #else
       (void)name;
@@ -87,19 +117,20 @@ namespace llarp
     }
 
     void
-    StatusObject::PutStringArray(const char* name,
-                                 std::vector< std::string >& arr)
+    StatusObject::PutStringArray(String_t name,
+                                 const std::vector< std::string >& arr)
     {
 #ifdef USE_ABYSS
       auto& a = Impl.GetAllocator();
       Value_t v;
       v.SetArray();
       Value_t i;
-      for(auto& str : arr)
+      for(const auto& str : arr)
       {
         v.PushBack(i.SetString(str.c_str(), a), a);
       }
-      Value_t k(name, a);
+      auto s = llarp::string_view_string(name);
+      Value_t k(s.c_str(), a);
       Impl.AddMember(k, v, a);
 #else
       (void)name;
@@ -108,13 +139,14 @@ namespace llarp
     }
 
     void
-    StatusObject::PutString(const char* name, const std::string& val)
+    StatusObject::PutString(String_t name, const std::string& val)
     {
 #ifdef USE_ABYSS
       auto& a = Impl.GetAllocator();
       Value_t v;
       v.SetString(val.c_str(), a);
-      Value_t k(name, a);
+      auto s = llarp::string_view_string(name);
+      Value_t k(s.c_str(), a);
       Impl.AddMember(k, v, a);
 #else
       (void)name;

llarp/util/status.hpp

@@ -3,8 +3,11 @@
 #ifdef USE_ABYSS
 #include <abyss/json.hpp>
 #endif
+#include <util/string_view.hpp>
 #include <vector>
 #include <string>
+#include <algorithm>
+#include <absl/types/variant.h>
 
 namespace llarp
 {
@@ -24,28 +27,45 @@ namespace llarp
 
     struct StatusObject
     {
-      StatusObject();
+      using String_t = llarp::string_view;
+      using Variant  = absl::variant< uint64_t, std::string, bool, StatusObject,
+                                     std::vector< std::string >,
+                                     std::vector< StatusObject > >;
+      using value_type = std::tuple< String_t, Variant >;
+
+      StatusObject(const StatusObject&);
       ~StatusObject();
 
-      void
-      PutInt(const char* name, uint64_t val);
+      StatusObject(std::initializer_list< value_type > vals)
+      {
+#ifdef USE_ABYSS
+        Impl.SetObject();
+#endif
+        std::for_each(vals.begin(), vals.end(),
+                      [&](const value_type& item) { Put(item); });
+      }
 
       void
-      PutString(const char* name, const std::string& val);
+      Put(String_t name, const Variant& value);
 
       void
-      PutBool(const char* name, bool val);
+      Put(const value_type& value);
 
-      void
-      PutObject(const char* name, StatusObject& obj);
+      StatusObject_Impl Impl;
 
+     private:
       void
-      PutStringArray(const char* name, std::vector< std::string >& arr);
-
+      PutBool(String_t name, bool val);
       void
-      PutObjectArray(const char* name, std::vector< StatusObject >& arr);
-
-      StatusObject_Impl Impl;
+      PutInt(String_t name, uint64_t val);
+      void
+      PutObject(String_t name, const StatusObject& val);
+      void
+      PutObjectArray(String_t name, const std::vector< StatusObject >& arr);
+      void
+      PutStringArray(String_t name, const std::vector< std::string >& arr);
+      void
+      PutString(String_t name, const std::string& val);
     };
 
     /// an entity that has a status that can be extracted
@@ -53,8 +73,8 @@ namespace llarp
     {
       virtual ~IStateful(){};
 
-      virtual void
-      ExtractStatus(StatusObject& state) const = 0;
+      virtual StatusObject
+      ExtractStatus() const = 0;
     };
 
   }  // namespace util

test/dht/test_llarp_dht_tx.cpp

@@ -1,5 +1,5 @@
 #include <dht/tx.hpp>
-
+#include <service/tag.hpp>
 #include <test_util.hpp>
 
 #include <gtest/gtest.h>
@@ -10,16 +10,18 @@ using namespace ::testing;
 
 using llarp::test::makeBuf;
 
+using Val_t = llarp::service::Tag;
+
 // Mock implementation of TX.
-struct TestTx final : public dht::TX< dht::Key_t, std::string >
+struct TestTx final : public dht::TX< dht::Key_t, Val_t >
 {
   TestTx(const dht::TXOwner& asker, const dht::Key_t& k,
          dht::AbstractContext* p)
-      : dht::TX< dht::Key_t, std::string >(asker, k, p)
+      : dht::TX< dht::Key_t, Val_t >(asker, k, p)
   {
   }
 
-  MOCK_CONST_METHOD1(Validate, bool(const std::string&));
+  MOCK_CONST_METHOD1(Validate, bool(const Val_t&));
 
   MOCK_METHOD1(Start, void(const dht::TXOwner&));
 
@@ -51,7 +53,7 @@ TEST_F(TestDhtTx, on_found)
   // - Repeated call on success after failure
 
   const auto key = makeBuf< dht::Key_t >(0x00);
-  std::string val("good value");
+  Val_t val("good value");
 
   // Validate returns true
   {
@@ -72,7 +74,7 @@ TEST_F(TestDhtTx, on_found)
   }
 
   const auto key1 = makeBuf< dht::Key_t >(0x01);
-  std::string badVal("bad value");
+  Val_t badVal("bad value");
 
   // Validate returns false
   {