diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 003b9e31c21..cd89b3e9625 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -5374,16 +5374,12 @@ void PeerManagerImpl::MaybeSendAddr(CNode& node, Peer& peer, std::chrono::micros
     // No addr messages to send
     if (peer.m_addrs_to_send.empty()) return;
 
-    const char* msg_type;
-    CNetAddr::Encoding ser_enc;
+    CNetMsgMaker mm(node.GetCommonVersion());
     if (peer.m_wants_addrv2) {
-        msg_type = NetMsgType::ADDRV2;
-        ser_enc = CNetAddr::Encoding::V2;
+        m_connman.PushMessage(&node, mm.Make(NetMsgType::ADDRV2, CAddress::V2_NETWORK(peer.m_addrs_to_send)));
     } else {
-        msg_type = NetMsgType::ADDR;
-        ser_enc = CNetAddr::Encoding::V1;
+        m_connman.PushMessage(&node, mm.Make(NetMsgType::ADDR, CAddress::V1_NETWORK(peer.m_addrs_to_send)));
     }
-    m_connman.PushMessage(&node, CNetMsgMaker(node.GetCommonVersion()).Make(msg_type, WithParams(CAddress::SerParams{{ser_enc}, CAddress::Format::Network}, peer.m_addrs_to_send)));
     peer.m_addrs_to_send.clear();
 
     // we only send the big addr message once
diff --git a/src/serialize.h b/src/serialize.h
index fd236f5a789..b09d6fbe608 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -214,11 +214,11 @@ const Out& AsBase(const In& x)
  *     }
  *   };
  * which would then be invoked as
- *   READWRITE(WithParams(BarParameter{...}, Using<FooFormatter>(obj.foo)))
+ *   READWRITE(BarParameter{...}(Using<FooFormatter>(obj.foo)))
  *
  * parameter(obj) can be invoked anywhere in the call stack; it is
  * passed down recursively into all serialization code, until another
- * WithParams overrides it.
+ * serialization parameter overrides it.
  *
  * Parameters will be implicitly converted where appropriate. This means that
  * "parent" serialization code can use a parameter that derives from, or is
@@ -1182,17 +1182,6 @@ public:
     }
 };
 
-/**
- * Return a wrapper around t that (de)serializes it with specified parameter params.
- *
- * See FORMATTER_METHODS_PARAMS for more information on serialization parameters.
- */
-template <typename Params, typename T>
-static auto WithParams(const Params& params, T&& t)
-{
-    return ParamsWrapper<Params, T>{params, t};
-}
-
 /**
  * Helper macro for SerParams structs
  *
@@ -1202,8 +1191,16 @@ static auto WithParams(const Params& params, T&& t)
  *   constexpr SerParams FOO{....};
  *   ss << FOO(obj);
  */
-#define SER_PARAMS_OPFUNC \
-    template <typename T> \
-    auto operator()(T&& t) const { return WithParams(*this, t); }
+#define SER_PARAMS_OPFUNC                                                                \
+    /**                                                                                  \
+     * Return a wrapper around t that (de)serializes it with specified parameter params. \
+     *                                                                                   \
+     * See FORMATTER_METHODS_PARAMS for more information on serialization parameters.    \
+     */                                                                                  \
+    template <typename T>                                                                \
+    auto operator()(T&& t) const                                                         \
+    {                                                                                    \
+        return ParamsWrapper{*this, t};                                                  \
+    }
 
 #endif // BITCOIN_SERIALIZE_H