evo: introduce the ability to store multiple lists of addresses

Author: kwvg

contrib/seeds/makeseeds.py

@@ -164,7 +164,7 @@ def main():
     mns = filtermulticollateraladdress(mns)
     mns = filtermultipayoutaddress(mns)
     # Extract IPs
-    ips = [parseip(mn['state']['addresses'][0]) for mn in mns]
+    ips = [parseip(mn['state']['addresses']['core_p2p'][0]) for mn in mns]
     for onion in onions:
         parsed = parseip(onion)
         if parsed is not None:

src/evo/deterministicmns.cpp

@@ -895,6 +895,9 @@ void CDeterministicMNManager::CleanupCache(int nHeight)
 template <typename ProTx>
 static bool CheckService(const ProTx& proTx, TxValidationState& state)
 {
+    if (!proTx.netInfo->HasEntries(NetInfoPurpose::CORE_P2P)) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-empty");
+    }
     switch (proTx.netInfo->Validate()) {
     case NetInfoStatus::BadAddress:
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr");

src/evo/netinfo.cpp

@@ -194,9 +194,9 @@ NetInfoStatus MnNetInfo::ValidateService(const CService& service)
     return NetInfoStatus::Success;
 }
 
-NetInfoStatus MnNetInfo::AddEntry(const std::string& input)
+NetInfoStatus MnNetInfo::AddEntry(const NetInfoPurpose purpose, const std::string& input)
 {
-    if (!IsEmpty()) {
+    if (purpose != NetInfoPurpose::CORE_P2P || !IsEmpty()) {
         return NetInfoStatus::MaxLimit;
     }
 
@@ -248,48 +248,61 @@ NetInfoStatus MnNetInfo::Validate() const
 
 UniValue MnNetInfo::ToJson() const
 {
-    if (IsEmpty()) {
-        return UniValue{UniValue::VARR};
+    UniValue ret{UniValue::VOBJ};
+    if (!IsEmpty()) {
+        ret.pushKV(PurposeToString(NetInfoPurpose::CORE_P2P).data(), ArrFromService(GetPrimary()));
     }
-    return ArrFromService(GetPrimary());
+    return ret;
 }
 
 std::string MnNetInfo::ToString() const
 {
-    return IsEmpty() ? "MnNetInfo()" : strprintf("MnNetInfo([%s])", m_addr.ToString());
+    return IsEmpty() ? "MnNetInfo()"
+                     : strprintf("MnNetInfo(NetInfo(purpose=%s, [%s]))", PurposeToString(NetInfoPurpose::CORE_P2P),
+                                 m_addr.ToString());
 }
 
 bool ExtNetInfo::HasDuplicates() const
 {
     std::unordered_set<std::string> known{};
-    for (const NetInfoEntry& entry : m_data) {
+    for (const auto& entry : m_all_entries) {
         if (auto [_, inserted] = known.insert(entry.ToStringAddr()); !inserted) {
             return true;
         }
     }
-    ASSERT_IF_DEBUG(known.size() == m_data.size());
+    ASSERT_IF_DEBUG(known.size() == m_all_entries.size());
     return false;
 }
 
 bool ExtNetInfo::IsDuplicateCandidate(const NetInfoEntry& candidate) const
 {
     const std::string& candidate_str{candidate.ToStringAddr()};
-    return std::any_of(m_data.begin(), m_data.end(),
+    return std::any_of(m_all_entries.begin(), m_all_entries.end(),
                        [&candidate_str](const auto& entry) { return candidate_str == entry.ToStringAddr(); });
 }
 
-NetInfoStatus ExtNetInfo::ProcessCandidate(const NetInfoEntry& candidate)
+NetInfoStatus ExtNetInfo::ProcessCandidate(const NetInfoPurpose purpose, const NetInfoEntry& candidate)
 {
     assert(candidate.IsTriviallyValid());
 
-    if (m_data.size() >= MAX_ENTRIES_EXTNETINFO) {
-        return NetInfoStatus::MaxLimit;
-    }
     if (IsDuplicateCandidate(candidate)) {
         return NetInfoStatus::Duplicate;
     }
-    m_data.push_back(candidate);
+    if (auto it{m_data.find(purpose)}; it != m_data.end()) {
+        // Existing entries list found, check limit
+        auto& [_, entries] = *it;
+        if (entries.size() >= MAX_ENTRIES_EXTNETINFO) {
+            return NetInfoStatus::MaxLimit;
+        }
+        entries.push_back(candidate);
+    } else {
+        // First entry for purpose code, create new entries list
+        auto [_, status] = m_data.try_emplace(purpose, std::vector<NetInfoEntry>({candidate}));
+        assert(status); // We did just check to see if our value already existed, try_emplace shouldn't fail
+    }
 
+    // Candidate succesfully added, update cache
+    m_all_entries.push_back(candidate);
     return NetInfoStatus::Success;
 }
 
@@ -311,8 +324,12 @@ NetInfoStatus ExtNetInfo::ValidateService(const CService& service)
     return NetInfoStatus::Success;
 }
 
-NetInfoStatus ExtNetInfo::AddEntry(const std::string& input)
+NetInfoStatus ExtNetInfo::AddEntry(const NetInfoPurpose purpose, const std::string& input)
 {
+    if (!IsValidPurpose(purpose)) {
+        return NetInfoStatus::MaxLimit;
+    }
+
     // We don't allow assuming ports, so we set the default value to 0 so that if no port is specified
     // it uses a fallback value of 0, which will return a NetInfoStatus::BadPort
     std::string addr;
@@ -326,7 +343,7 @@ NetInfoStatus ExtNetInfo::AddEntry(const std::string& input)
     if (auto service_opt{Lookup(addr, /*portDefault=*/port, /*fAllowLookup=*/false)}) {
         const auto ret{ValidateService(*service_opt)};
         if (ret == NetInfoStatus::Success) {
-            return ProcessCandidate(NetInfoEntry{*service_opt});
+            return ProcessCandidate(purpose, NetInfoEntry{*service_opt});
         }
         return ret; /* ValidateService() failed */
     }
@@ -335,19 +352,33 @@ NetInfoStatus ExtNetInfo::AddEntry(const std::string& input)
 
 NetInfoList ExtNetInfo::GetEntries() const
 {
-    return m_data;
+    // ExtNetInfo is an append-only structure, we can avoid re-calculating
+    // a list of all entries by maintaining a small cache.
+    return m_all_entries;
 }
 
 CService ExtNetInfo::GetPrimary() const
 {
-    if (m_data.size() >= 1) {
-        if (const auto& service_opt{m_data[0].GetAddrPort()}) {
-            return *service_opt;
+    if (const auto& it{m_data.find(NetInfoPurpose::CORE_P2P)}; it != m_data.end()) {
+        const auto& [_, entries] = *it;
+        // If a purpose code is in the map, there should be at least one entry
+        ASSERT_IF_DEBUG(!entries.empty());
+        if (entries.size() >= 1) {
+            if (const auto& service_opt{entries[0].GetAddrPort()}) {
+                return *service_opt;
+            }
         }
     }
     return CService{};
 }
 
+bool ExtNetInfo::HasEntries(NetInfoPurpose purpose) const
+{
+    if (!IsValidPurpose(purpose)) return false;
+    const auto& it{m_data.find(purpose)};
+    return it != m_data.end() && !it->second.empty();
+}
+
 NetInfoStatus ExtNetInfo::Validate() const
 {
     if (m_version == 0 || m_version > CURRENT_VERSION || m_data.empty()) {
@@ -356,36 +387,60 @@ NetInfoStatus ExtNetInfo::Validate() const
     if (HasDuplicates()) {
         return NetInfoStatus::Duplicate;
     }
-    for (const auto& entry : m_data) {
-        if (!entry.IsTriviallyValid()) {
-            // Trivially invalid NetInfoEntry, no point checking against consensus rules
+    for (const auto& [purpose, entries] : m_data) {
+        if (!IsValidPurpose(purpose)) {
             return NetInfoStatus::Malformed;
         }
-        if (const auto& service_opt{entry.GetAddrPort()}) {
-            if (auto ret{ValidateService(*service_opt)}; ret != NetInfoStatus::Success) {
-                // Stores CService underneath but doesn't pass validation rules
-                return ret;
-            }
-        } else {
-            // Doesn't store valid type underneath
+        if (entries.empty()) {
+            // Purpose if present in map must have at least one entry
             return NetInfoStatus::Malformed;
         }
+        for (const auto& entry : entries) {
+            if (!entry.IsTriviallyValid()) {
+                // Trivially invalid NetInfoEntry, no point checking against consensus rules
+                return NetInfoStatus::Malformed;
+            }
+            if (const auto& service_opt{entry.GetAddrPort()}) {
+                if (auto ret{ValidateService(*service_opt)}; ret != NetInfoStatus::Success) {
+                    // Stores CService underneath but doesn't pass validation rules
+                    return ret;
+                }
+            } else {
+                // Doesn't store valid type underneath
+                return NetInfoStatus::Malformed;
+            }
+        }
     }
     return NetInfoStatus::Success;
 }
 
 UniValue ExtNetInfo::ToJson() const
 {
-    UniValue ret(UniValue::VARR);
-    for (const auto& entry : m_data) {
-        ret.push_back(entry.ToStringAddrPort());
+    UniValue ret(UniValue::VOBJ);
+    for (const auto& [purpose, entries] : m_data) {
+        UniValue arr(UniValue::VARR);
+        for (const auto& entry : entries) {
+            arr.push_back(entry.ToStringAddrPort());
+        }
+        ret.pushKV(PurposeToString(purpose).data(), arr);
     }
     return ret;
 }
 
 std::string ExtNetInfo::ToString() const
 {
-    return IsEmpty()
-               ? "ExtNetInfo()"
-               : strprintf("ExtNetInfo([%s])", Join(m_data, ", ", [](const auto& entry) { return entry.ToString(); }));
+    return IsEmpty() ? "ExtNetInfo()" : strprintf("ExtNetInfo(%s)", [&]() -> std::string {
+        std::string ret{};
+        bool first{true};
+        for (const auto& [purpose, entries] : m_data) {
+            if (!first) { ret += ", "; } else { first = false; }
+            ret += strprintf("NetInfo(purpose=%s, [%s])", PurposeToString(purpose), [&]() -> std::string {
+                if (entries.empty()) {
+                    return "invalid list";
+                }
+                return Join(entries, ", ", [](const auto& entry) { return entry.ToString(); });
+            }());
+        }
+        return ret;
+    }());
 }

src/evo/netinfo.h

@@ -15,7 +15,7 @@ class CService;
 
 class UniValue;
 
-/** Maximum entries that can be stored in an ExtNetInfo */
+/** Maximum entries that can be stored in an ExtNetInfo per purpose code */
 static constexpr uint8_t MAX_ENTRIES_EXTNETINFO{4};
 
 enum class NetInfoStatus : uint8_t {
@@ -59,6 +59,34 @@ constexpr std::string_view NISToString(const NetInfoStatus code)
     assert(false);
 }
 
+// A purpose corresponds to the index position in the ExtNetInfo map, entries must
+// be contiguous and cannot be changed once set without a format version update
+enum class NetInfoPurpose : uint8_t {
+    // Mandatory for masternodes
+    CORE_P2P = 0,
+};
+
+template<> struct is_serializable_enum<NetInfoPurpose> : std::true_type {};
+
+constexpr bool IsValidPurpose(const NetInfoPurpose purpose)
+{
+    switch (purpose) {
+    case NetInfoPurpose::CORE_P2P:
+        return true;
+    } // no default case, so the compiler can warn about missing cases
+    return false;
+}
+
+// Warning: Used in RPC code, altering existing values is a breaking change
+constexpr std::string_view PurposeToString(const NetInfoPurpose purpose)
+{
+    switch (purpose) {
+    case NetInfoPurpose::CORE_P2P:
+        return "core_p2p";
+    } // no default case, so the compiler can warn about missing cases
+    return "";
+}
+
 /* Identical to IsDeprecatedRPCEnabled("service"). For use outside of RPC code. */
 bool IsServiceDeprecatedRPCEnabled();
 
@@ -145,11 +173,12 @@ class NetInfoInterface
 public:
     virtual ~NetInfoInterface() = default;
 
-    virtual NetInfoStatus AddEntry(const std::string& service) = 0;
+    virtual NetInfoStatus AddEntry(const NetInfoPurpose purpose, const std::string& service) = 0;
     virtual NetInfoList GetEntries() const = 0;
 
     virtual CService GetPrimary() const = 0;
     virtual bool CanStorePlatform() const = 0;
+    virtual bool HasEntries(NetInfoPurpose purpose) const = 0;
     virtual bool IsEmpty() const = 0;
     virtual NetInfoStatus Validate() const = 0;
     virtual UniValue ToJson() const = 0;
@@ -202,10 +231,11 @@ class MnNetInfo final : public NetInfoInterface
         m_addr = NetInfoEntry{service};
     }
 
-    NetInfoStatus AddEntry(const std::string& service) override;
+    NetInfoStatus AddEntry(const NetInfoPurpose purpose, const std::string& service) override;
     NetInfoList GetEntries() const override;
 
     CService GetPrimary() const override;
+    bool HasEntries(NetInfoPurpose purpose) const override { return purpose == NetInfoPurpose::CORE_P2P && !IsEmpty(); }
     bool IsEmpty() const override { return m_addr.IsEmpty(); }
     bool CanStorePlatform() const override { return false; }
     NetInfoStatus Validate() const override;
@@ -238,14 +268,17 @@ class ExtNetInfo final : public NetInfoInterface
     bool IsDuplicateCandidate(const NetInfoEntry& candidate) const;
 
     /** Validate uniqueness requirements and add to object if passed */
-    NetInfoStatus ProcessCandidate(const NetInfoEntry& candidate);
+    NetInfoStatus ProcessCandidate(const NetInfoPurpose purpose, const NetInfoEntry& candidate);
 
     /** Validate CService candidate address against ruleset */
     static NetInfoStatus ValidateService(const CService& service);
 
 private:
     uint8_t m_version{CURRENT_VERSION};
-    NetInfoList m_data{};
+    std::map<NetInfoPurpose, NetInfoList> m_data{};
+
+    // memory only
+    NetInfoList m_all_entries{};
 
 public:
     ExtNetInfo() = default;
@@ -254,19 +287,37 @@ class ExtNetInfo final : public NetInfoInterface
 
     ~ExtNetInfo() = default;
 
-    SERIALIZE_METHODS(ExtNetInfo, obj)
+    template <typename Stream>
+    void Serialize(Stream& s) const
+    {
+        s << m_version;
+        if (m_version == 0 || m_version > CURRENT_VERSION) {
+            return; // Don't bother with unknown versions
+        }
+        s << m_data;
+    }
+
+    template <typename Stream>
+    void Unserialize(Stream& s)
     {
-        READWRITE(obj.m_version);
-        if (obj.m_version == 0 || obj.m_version > CURRENT_VERSION) {
+        s >> m_version;
+        if (m_version == 0 || m_version > CURRENT_VERSION) {
             return; // Don't bother with unknown versions
         }
-        READWRITE(obj.m_data);
+        s >> m_data;
+
+        // Regenerate internal cache
+        m_all_entries.clear();
+        for (const auto& [_, entries] : m_data) {
+            m_all_entries.insert(m_all_entries.end(), entries.begin(), entries.end());
+        }
     }
 
-    NetInfoStatus AddEntry(const std::string& input) override;
+    NetInfoStatus AddEntry(const NetInfoPurpose purpose, const std::string& input) override;
     NetInfoList GetEntries() const override;
 
     CService GetPrimary() const override;
+    bool HasEntries(NetInfoPurpose purpose) const override;
     bool IsEmpty() const override { return m_version == CURRENT_VERSION && m_data.empty(); }
     bool CanStorePlatform() const override
     {
@@ -282,6 +333,7 @@ class ExtNetInfo final : public NetInfoInterface
     {
         m_version = CURRENT_VERSION;
         m_data.clear();
+        m_all_entries.clear();
     }
 
 private: