diff --git a/src/Makefile.am b/src/Makefile.am
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -407,6 +407,7 @@
   script/sigencoding.cpp \
   script/sigencoding.h \
   serialize.h \
+  span.h \
   tinyformat.h \
   uint256.cpp \
   uint256.h \
diff --git a/src/compressor.h b/src/compressor.h
--- a/src/compressor.h
+++ b/src/compressor.h
@@ -9,6 +9,7 @@
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <serialize.h>
+#include <span.h>
 
 class CKeyID;
 class CPubKey;
@@ -52,12 +53,12 @@
     template <typename Stream> void Serialize(Stream &s) const {
         std::vector<uint8_t> compr;
         if (CompressScript(script, compr)) {
-            s << CFlatData(compr);
+            s << MakeSpan(compr);
             return;
         }
         unsigned int nSize = script.size() + nSpecialScripts;
         s << VARINT(nSize);
-        s << CFlatData(script);
+        s << MakeSpan(script);
     }
 
     template <typename Stream> void Unserialize(Stream &s) {
@@ -65,7 +66,7 @@
         s >> VARINT(nSize);
         if (nSize < nSpecialScripts) {
             std::vector<uint8_t> vch(GetSpecialScriptSize(nSize), 0x00);
-            s >> CFlatData(vch);
+            s >> MakeSpan(vch);
             DecompressScript(script, nSize, vch);
             return;
         }
@@ -76,7 +77,7 @@
             s.ignore(nSize);
         } else {
             script.resize(nSize);
-            s >> CFlatData(script);
+            s >> MakeSpan(script);
         }
     }
 };
diff --git a/src/netaddress.h b/src/netaddress.h
--- a/src/netaddress.h
+++ b/src/netaddress.h
@@ -11,6 +11,7 @@
 
 #include <compat.h>
 #include <serialize.h>
+#include <span.h>
 
 #include <cstdint>
 #include <string>
@@ -191,7 +192,7 @@
     inline void SerializationOp(Stream &s, Operation ser_action) {
         READWRITE(ip);
         unsigned short portN = htons(port);
-        READWRITE(FLATDATA(portN));
+        READWRITE(Span<uint8_t>((uint8_t *)&portN, 2));
         if (ser_action.ForRead()) {
             port = ntohs(portN);
         }
diff --git a/src/serialize.h b/src/serialize.h
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -8,6 +8,7 @@
 
 #include <compat/endian.h>
 #include <prevector.h>
+#include <span.h>
 
 #include <algorithm>
 #include <array>
@@ -39,8 +40,8 @@
 constexpr deserialize_type deserialize{};
 
 /**
- * Used to bypass the rule against non-const reference to temporary where it
- * makes sense with wrappers such as CFlatData or CTxDB
+ * Used to bypass the rule against non-const reference to temporary
+ * where it makes sense with wrappers.
  */
 template <typename T> inline T &REF(const T &val) {
     return const_cast<T &>(val);
@@ -260,6 +261,14 @@
     s.write(a.data(), N);
 }
 #endif
+template <typename Stream>
+inline void Serialize(Stream &s, const Span<const uint8_t> &span) {
+    s.write(CharCast(span.data()), span.size());
+}
+template <typename Stream>
+inline void Serialize(Stream &s, const Span<uint8_t> &span) {
+    s.write(CharCast(span.data()), span.size());
+}
 template <typename Stream> inline void Unserialize(Stream &s, int8_t &a) {
     a = ser_readdata8(s);
 }
@@ -325,6 +334,10 @@
     char f = ser_readdata8(s);
     a = f;
 }
+template <typename Stream>
+inline void Unserialize(Stream &s, Span<uint8_t> &span) {
+    s.read(CharCast(span.data()), span.size());
+}
 
 /**
  * Compact Size
@@ -491,45 +504,10 @@
     }
 }
 
-#define FLATDATA(obj) CFlatData((char *)&(obj), (char *)&(obj) + sizeof(obj))
 #define VARINT(obj, ...) WrapVarInt<__VA_ARGS__>(REF(obj))
 #define COMPACTSIZE(obj) CCompactSize(REF(obj))
 #define LIMITED_STRING(obj, n) LimitedString<n>(REF(obj))
 
-/**
- * Wrapper for serializing arrays and POD.
- */
-class CFlatData {
-protected:
-    char *pbegin;
-    char *pend;
-
-public:
-    CFlatData(void *pbeginIn, void *pendIn)
-        : pbegin((char *)pbeginIn), pend((char *)pendIn) {}
-    template <class T, class TAl> explicit CFlatData(std::vector<T, TAl> &v) {
-        pbegin = (char *)v.data();
-        pend = (char *)(v.data() + v.size());
-    }
-    template <unsigned int N, typename T, typename S, typename D>
-    explicit CFlatData(prevector<N, T, S, D> &v) {
-        pbegin = (char *)v.data();
-        pend = (char *)(v.data() + v.size());
-    }
-    char *begin() { return pbegin; }
-    const char *begin() const { return pbegin; }
-    char *end() { return pend; }
-    const char *end() const { return pend; }
-
-    template <typename Stream> void Serialize(Stream &s) const {
-        s.write(pbegin, pend - pbegin);
-    }
-
-    template <typename Stream> void Unserialize(Stream &s) {
-        s.read(pbegin, pend - pbegin);
-    }
-};
-
 template <VarIntMode Mode, typename I> class CVarInt {
 protected:
     I &n;
diff --git a/src/span.h b/src/span.h
new file mode 100644
--- /dev/null
+++ b/src/span.h
@@ -0,0 +1,47 @@
+// Copyright (c) 2018 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_SPAN_H
+#define BITCOIN_SPAN_H
+
+#include <cstddef>
+#include <type_traits>
+
+/** A Span is an object that can refer to a contiguous sequence of objects.
+ *
+ * It implements a subset of C++20's std::span.
+ */
+template <typename C> class Span {
+    C *m_data;
+    std::ptrdiff_t m_size;
+
+public:
+    constexpr Span() noexcept : m_data(nullptr), m_size(0) {}
+    constexpr Span(C *data, std::ptrdiff_t size) noexcept
+        : m_data(data), m_size(size) {}
+
+    constexpr C *data() const noexcept { return m_data; }
+    constexpr std::ptrdiff_t size() const noexcept { return m_size; }
+};
+
+/** Create a span to a container exposing data() and size().
+ *
+ * This correctly deals with constness: the returned Span's element type will be
+ * whatever data() returns a pointer to. If either the passed container is
+ * const, or its element type is const, the resulting span will have a const
+ * element type.
+ *
+ * std::span will have a constructor that implements this functionality
+ * directly.
+ */
+template <typename V>
+constexpr Span<
+    typename std::remove_pointer<decltype(std::declval<V>().data())>::type>
+MakeSpan(V &v) {
+    return Span<
+        typename std::remove_pointer<decltype(std::declval<V>().data())>::type>(
+        v.data(), v.size());
+}
+
+#endif // BITCOIN_SPAN_H