diff --git a/quic/api/QuicTransportBase.cpp b/quic/api/QuicTransportBase.cpp
index 772fec96c..774d6ef8e 100644
--- a/quic/api/QuicTransportBase.cpp
+++ b/quic/api/QuicTransportBase.cpp
@@ -1905,7 +1905,8 @@ void QuicTransportBase::onNetworkData(
       onReadData(
           peer,
           NetworkDataSingle(
-              std::move(packet.buf), networkData.receiveTimePoint));
+              ReceivedPacket(std::move(packet.buf)),
+              networkData.receiveTimePoint));
       if (conn_->peerConnectionError) {
         closeImpl(QuicError(
             QuicErrorCode(TransportErrorCode::NO_ERROR), "Peer closed"));
diff --git a/quic/api/test/QuicTransportBaseTest.cpp b/quic/api/test/QuicTransportBaseTest.cpp
index 191bf0bc4..d14004e5e 100644
--- a/quic/api/test/QuicTransportBaseTest.cpp
+++ b/quic/api/test/QuicTransportBaseTest.cpp
@@ -265,10 +265,10 @@ class TestQuicTransport
 
   void onReadData(const folly::SocketAddress&, NetworkDataSingle&& data)
       override {
-    if (!data.data) {
+    if (!data.packet.buf) {
       return;
     }
-    folly::io::Cursor cursor(data.data.get());
+    folly::io::Cursor cursor(data.packet.buf.get());
     while (!cursor.isAtEnd()) {
       // create server chosen connId with processId = 0 and workerId = 0
       ServerConnectionIdParams params(0, 0, 0);
diff --git a/quic/client/QuicClientTransport.cpp b/quic/client/QuicClientTransport.cpp
index 6e6319ef4..afd4761fb 100644
--- a/quic/client/QuicClientTransport.cpp
+++ b/quic/client/QuicClientTransport.cpp
@@ -122,7 +122,7 @@ void QuicClientTransport::processUDPData(
     const folly::SocketAddress& peer,
     NetworkDataSingle&& networkData) {
   BufQueue udpData;
-  udpData.append(std::move(networkData.data));
+  udpData.append(std::move(networkData.packet.buf));
 
   if (!conn_->version) {
     // We only check for version negotiation packets before the version
@@ -155,7 +155,7 @@ void QuicClientTransport::processUDPData(
       !clientConn_->pendingOneRttData.empty()) {
     BufQueue pendingPacket;
     for (auto& pendingData : clientConn_->pendingOneRttData) {
-      pendingPacket.append(std::move(pendingData.networkData.data));
+      pendingPacket.append(std::move(pendingData.networkData.packet.buf));
       processPacketData(
           pendingData.peer,
           pendingData.networkData.receiveTimePoint,
@@ -168,7 +168,7 @@ void QuicClientTransport::processUDPData(
       !clientConn_->pendingHandshakeData.empty()) {
     BufQueue pendingPacket;
     for (auto& pendingData : clientConn_->pendingHandshakeData) {
-      pendingPacket.append(std::move(pendingData.networkData.data));
+      pendingPacket.append(std::move(pendingData.networkData.packet.buf));
       processPacketData(
           pendingData.peer,
           pendingData.networkData.receiveTimePoint,
@@ -270,7 +270,8 @@ void QuicClientTransport::processPacketData(
         : clientConn_->pendingHandshakeData;
     pendingData.emplace_back(
         NetworkDataSingle(
-            std::move(cipherUnavailable->packet), receiveTimePoint),
+            ReceivedPacket(std::move(cipherUnavailable->packet)),
+            receiveTimePoint),
         peer);
     if (conn_->qLogger) {
       conn_->qLogger->addPacketBuffered(
diff --git a/quic/server/QuicServerTransport.cpp b/quic/server/QuicServerTransport.cpp
index b1fed6506..22a603be0 100644
--- a/quic/server/QuicServerTransport.cpp
+++ b/quic/server/QuicServerTransport.cpp
@@ -512,7 +512,7 @@ void QuicServerTransport::processPendingData(bool async) {
         serverPtr->onNetworkData(
             pendingPacket.peer,
             NetworkData(
-                std::move(pendingPacket.networkData.data),
+                std::move(pendingPacket.networkData.packet.buf),
                 pendingPacket.networkData.receiveTimePoint));
         if (serverPtr->closeState_ == CloseState::CLOSED) {
           // The pending data could potentially contain a connection close, or
diff --git a/quic/server/state/ServerStateMachine.cpp b/quic/server/state/ServerStateMachine.cpp
index 6742f6863..7c16bf0d1 100644
--- a/quic/server/state/ServerStateMachine.cpp
+++ b/quic/server/state/ServerStateMachine.cpp
@@ -707,7 +707,8 @@ static void handleCipherUnavailable(
     ServerEvents::ReadData pendingReadData;
     pendingReadData.peer = readData.peer;
     pendingReadData.networkData = NetworkDataSingle(
-        std::move(originalData->packet), readData.networkData.receiveTimePoint);
+        ReceivedPacket(std::move(originalData->packet)),
+        readData.networkData.receiveTimePoint);
     pendingData->emplace_back(std::move(pendingReadData));
     VLOG(10) << "Adding pending data to "
              << toString(originalData->protectionType)
@@ -731,15 +732,15 @@ void onServerReadDataFromOpen(
     ServerEvents::ReadData& readData) {
   CHECK_EQ(conn.state, ServerState::Open);
   // Don't bother parsing if the data is empty.
-  if (!readData.networkData.data ||
-      readData.networkData.data->computeChainDataLength() == 0) {
+  if (!readData.networkData.packet.buf ||
+      readData.networkData.packet.buf->computeChainDataLength() == 0) {
     return;
   }
   bool firstPacketFromPeer = false;
   if (!conn.readCodec) {
     firstPacketFromPeer = true;
 
-    folly::io::Cursor cursor(readData.networkData.data.get());
+    folly::io::Cursor cursor(readData.networkData.packet.buf.get());
     auto initialByte = cursor.readBE<uint8_t>();
     auto parsedLongHeader = parseLongHeaderInvariant(initialByte, cursor);
     if (!parsedLongHeader) {
@@ -848,7 +849,7 @@ void onServerReadDataFromOpen(
     conn.peerAddress = conn.originalPeerAddress;
   }
   BufQueue udpData;
-  udpData.append(std::move(readData.networkData.data));
+  udpData.append(std::move(readData.networkData.packet.buf));
   for (uint16_t processedPackets = 0;
        !udpData.empty() && processedPackets < kMaxNumCoalescedPackets;
        processedPackets++) {
@@ -1374,7 +1375,7 @@ void onServerReadDataFromClosed(
     ServerEvents::ReadData& readData) {
   CHECK_EQ(conn.state, ServerState::Closed);
   BufQueue udpData;
-  udpData.append(std::move(readData.networkData.data));
+  udpData.append(std::move(readData.networkData.packet.buf));
   auto packetSize = udpData.empty() ? 0 : udpData.chainLength();
   if (!conn.readCodec) {
     // drop data. We closed before we even got the first packet. This is
diff --git a/quic/state/StateData.h b/quic/state/StateData.h
index e289de365..abe0147cd 100644
--- a/quic/state/StateData.h
+++ b/quic/state/StateData.h
@@ -45,6 +45,7 @@
 namespace quic {
 
 struct ReceivedPacket {
+  ReceivedPacket() = default;
   explicit ReceivedPacket(Buf&& bufIn) : buf(std::move(bufIn)) {}
 
   // data
@@ -65,8 +66,10 @@ struct NetworkData {
     }
   }
 
-  NetworkData(std::vector<Buf>&& packetBufs, const TimePoint& receiveTime)
-      : receiveTimePoint(receiveTime),
+  NetworkData(
+      std::vector<Buf>&& packetBufs,
+      const TimePoint& receiveTimePointIn)
+      : receiveTimePoint(receiveTimePointIn),
         packets([&packetBufs]() {
           std::vector<ReceivedPacket> result;
           result.reserve(packetBufs.size());
@@ -97,18 +100,18 @@ struct NetworkData {
 };
 
 struct NetworkDataSingle {
-  Buf data;
+  ReceivedPacket packet;
   TimePoint receiveTimePoint;
   size_t totalData{0};
 
   NetworkDataSingle() = default;
 
   NetworkDataSingle(
-      std::unique_ptr<folly::IOBuf> buf,
-      const TimePoint& receiveTime)
-      : data(std::move(buf)), receiveTimePoint(receiveTime) {
-    if (data) {
-      totalData += data->computeChainDataLength();
+      ReceivedPacket&& packetIn,
+      const TimePoint& receiveTimePointIn)
+      : packet(std::move(packetIn)), receiveTimePoint(receiveTimePointIn) {
+    if (packet.buf) {
+      totalData += packet.buf->computeChainDataLength();
     }
   }
 };