evo: change internal type of MnNetInfo to NetInfoEntry

Author: kwvg

src/evo/deterministicmns.cpp

@@ -1213,6 +1213,8 @@ static bool CheckService(const ProTx& proTx, TxValidationState& state)
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr-type");
     case NetInfoStatus::NotRoutable:
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr-unroutable");
+    case NetInfoStatus::Malformed:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-bad");
     case NetInfoStatus::Success:
         return true;
     // Shouldn't be possible during self-checks

src/evo/netinfo.cpp

@@ -163,12 +163,11 @@ NetInfoStatus MnNetInfo::ValidateService(const CService& service)
 
 NetInfoStatus MnNetInfo::AddEntry(const std::string& input)
 {
-    if (auto service = Lookup(input, /*portDefault=*/Params().GetDefaultPort(), /*fAllowLookup=*/false);
-        service.has_value()) {
-        const auto ret = ValidateService(service.value());
+    if (auto service_opt{Lookup(input, /*portDefault=*/Params().GetDefaultPort(), /*fAllowLookup=*/false)}) {
+        const auto ret{ValidateService(*service_opt)};
         if (ret == NetInfoStatus::Success) {
-            m_addr = service.value();
-            ASSERT_IF_DEBUG(m_addr != empty_service);
+            m_addr = NetInfoEntry{*service_opt};
+            ASSERT_IF_DEBUG(GetPrimary() != empty_service);
         }
         return ret;
     }
@@ -179,18 +178,34 @@ CServiceList MnNetInfo::GetEntries() const
 {
     CServiceList ret;
     if (!IsEmpty()) {
-        ASSERT_IF_DEBUG(m_addr != empty_service);
-        ret.push_back(m_addr);
+        ASSERT_IF_DEBUG(GetPrimary() != empty_service);
+        ret.push_back(GetPrimary());
     }
     // If MnNetInfo is empty, we probably don't expect any entries to show up, so
     // we return a blank set instead.
     return ret;
 }
 
+const CService& MnNetInfo::GetPrimary() const
+{
+    if (const auto& service_opt{m_addr.GetAddrPort()}) {
+        return *service_opt;
+    }
+    return empty_service;
+}
+
+NetInfoStatus MnNetInfo::Validate() const
+{
+    if (!m_addr.IsTriviallyValid()) {
+        return NetInfoStatus::Malformed;
+    }
+    return ValidateService(GetPrimary());
+}
+
 std::string MnNetInfo::ToString() const
 {
     // Extra padding to account for padding done by the calling function.
     return strprintf("MnNetInfo()\n"
-                     "    CService(addr=%s, port=%u)\n",
-                     m_addr.ToStringAddr(), m_addr.GetPort());
+                     "    %s\n",
+                     m_addr.ToString());
 }

src/evo/netinfo.h

@@ -22,6 +22,7 @@ enum class NetInfoStatus : uint8_t {
     BadPort,
     BadType,
     NotRoutable,
+    Malformed,
 
     Success
 };
@@ -39,6 +40,8 @@ constexpr std::string_view NISToString(const NetInfoStatus code)
         return "invalid address type";
     case NetInfoStatus::NotRoutable:
         return "unroutable address";
+    case NetInfoStatus::Malformed:
+        return "malformed";
     case NetInfoStatus::Success:
         return "success";
     } // no default case, so the compiler can warn about missing cases
@@ -121,7 +124,7 @@ using CServiceList = std::vector<std::reference_wrapper<const CService>>;
 class MnNetInfo
 {
 private:
-    CService m_addr{};
+    NetInfoEntry m_addr{};
 
 private:
     static NetInfoStatus ValidateService(const CService& service);
@@ -133,20 +136,38 @@ class MnNetInfo
     bool operator==(const MnNetInfo& rhs) const { return m_addr == rhs.m_addr; }
     bool operator!=(const MnNetInfo& rhs) const { return !(*this == rhs); }
 
-    SERIALIZE_METHODS(MnNetInfo, obj)
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
+        if (const auto& service{m_addr.GetAddrPort()}; service.has_value()) {
+            s << service->get();
+        } else {
+            s << CService{};
+        }
+    }
+
+    void Serialize(CSizeComputer& s) const
+    {
+        s.seek(::GetSerializeSize(CService{}, s.GetVersion()));
+    }
+
+    template <typename Stream>
+    void Unserialize(Stream& s)
     {
-        READWRITE(obj.m_addr);
+        CService service;
+        s >> service;
+        m_addr = NetInfoEntry{service};
     }
 
     NetInfoStatus AddEntry(const std::string& service);
     CServiceList GetEntries() const;
 
-    const CService& GetPrimary() const { return m_addr; }
+    const CService& GetPrimary() const;
     bool IsEmpty() const { return *this == MnNetInfo(); }
-    NetInfoStatus Validate() const { return ValidateService(m_addr); }
+    NetInfoStatus Validate() const;
     std::string ToString() const;
 
-    void Clear() { m_addr = CService(); }
+    void Clear() { m_addr.Clear(); }
 };
 
 #endif // BITCOIN_EVO_NETINFO_H

src/test/evo_netinfo_tests.cpp

@@ -49,8 +49,11 @@ BOOST_AUTO_TEST_CASE(mnnetinfo_rules)
         MnNetInfo netInfo;
         BOOST_CHECK_EQUAL(netInfo.AddEntry(input), expected_ret);
         if (expected_ret != NetInfoStatus::Success) {
+            // An empty MnNetInfo is considered malformed
+            BOOST_CHECK_EQUAL(netInfo.Validate(), NetInfoStatus::Malformed);
             BOOST_CHECK(netInfo.GetEntries().empty());
         } else {
+            BOOST_CHECK_EQUAL(netInfo.Validate(), NetInfoStatus::Success);
             ValidateGetEntries(netInfo.GetEntries(), /*expected_size=*/1);
         }
     }
@@ -160,4 +163,44 @@ BOOST_AUTO_TEST_CASE(netinfo_retvals)
     BOOST_CHECK(entry < entry_empty);
 }
 
+bool CheckIfSerSame(const CService& lhs, const MnNetInfo& rhs)
+{
+    CHashWriter ss_lhs(SER_GETHASH, 0), ss_rhs(SER_GETHASH, 0);
+    ss_lhs << lhs;
+    ss_rhs << rhs;
+    return ss_lhs.GetSHA256() == ss_rhs.GetSHA256();
+}
+
+BOOST_AUTO_TEST_CASE(cservice_compatible)
+{
+    // Empty values should be the same
+    CService service;
+    MnNetInfo netInfo;
+    BOOST_CHECK(CheckIfSerSame(service, netInfo));
+
+    // Valid IPv4 address, valid port
+    service = LookupNumeric("1.1.1.1", 9999);
+    netInfo.Clear();
+    BOOST_CHECK_EQUAL(netInfo.AddEntry("1.1.1.1:9999"), NetInfoStatus::Success);
+    BOOST_CHECK(CheckIfSerSame(service, netInfo));
+
+    // Valid IPv4 address, default P2P port implied
+    service = LookupNumeric("1.1.1.1", Params().GetDefaultPort());
+    netInfo.Clear();
+    BOOST_CHECK_EQUAL(netInfo.AddEntry("1.1.1.1"), NetInfoStatus::Success);
+    BOOST_CHECK(CheckIfSerSame(service, netInfo));
+
+    // Lookup() failure (domains not allowed), MnNetInfo should remain empty if Lookup() failed
+    service = CService();
+    netInfo.Clear();
+    BOOST_CHECK_EQUAL(netInfo.AddEntry("example.com"), NetInfoStatus::BadInput);
+    BOOST_CHECK(CheckIfSerSame(service, netInfo));
+
+    // Validation failure (non-IPv4 not allowed), MnNetInfo should remain empty if ValidateService() failed
+    service = CService();
+    netInfo.Clear();
+    BOOST_CHECK_EQUAL(netInfo.AddEntry("[2606:4700:4700::1111]:9999"), NetInfoStatus::BadType);
+    BOOST_CHECK(CheckIfSerSame(service, netInfo));
+}
+
 BOOST_AUTO_TEST_SUITE_END()