diff --git a/libraries/networking/src/udt/Constants.h b/libraries/networking/src/udt/Constants.h
index 9f5f1db883..a13997e9a3 100644
--- a/libraries/networking/src/udt/Constants.h
+++ b/libraries/networking/src/udt/Constants.h
@@ -26,10 +26,63 @@ namespace udt {
     static const int UDP_SEND_BUFFER_SIZE_BYTES = 1048576;
     static const int UDP_RECEIVE_BUFFER_SIZE_BYTES = 1048576;
     static const int DEFAULT_SYN_INTERVAL_USECS = 10 * 1000;
-    static const int SEQUENCE_NUMBER_BITS = sizeof(SequenceNumber) * 8;
-    static const int MESSAGE_LINE_NUMBER_BITS = 32;
-    static const int MESSAGE_NUMBER_BITS = 30;
-    static const uint32_t CONTROL_BIT_MASK = uint32_t(1) << (SEQUENCE_NUMBER_BITS - 1);
+
+    // Header constants
+
+    // Bit sizes (in order)
+    static const int CONTROL_BIT_SIZE = 1;
+    static const int RELIABILITY_BIT_SIZE = 1;
+    static const int MESSAGE_BIT_SIZE = 1;
+    static const int OBFUSCATION_LEVEL_SIZE = 2;
+    static const int SEQUENCE_NUMBER_SIZE= 27;
+
+    static const int PACKET_POSITION_SIZE = 2;
+    static const int MESSAGE_NUMBER_SIZE = 30;
+
+    static const int MESSAGE_PART_NUMBER_SIZE = 32;
+
+    // Offsets
+    static const int SEQUENCE_NUMBER_OFFSET = 0;
+    static const int OBFUSCATION_LEVEL_OFFSET = SEQUENCE_NUMBER_OFFSET + SEQUENCE_NUMBER_SIZE;
+    static const int MESSAGE_BIT_OFFSET = OBFUSCATION_LEVEL_OFFSET + OBFUSCATION_LEVEL_SIZE;
+    static const int RELIABILITY_BIT_OFFSET = MESSAGE_BIT_OFFSET + MESSAGE_BIT_SIZE;
+    static const int CONTROL_BIT_OFFSET = RELIABILITY_BIT_OFFSET + RELIABILITY_BIT_SIZE;
+
+    static const int MESSAGE_NUMBER_OFFSET = 0;
+    static const int PACKET_POSITION_OFFSET = MESSAGE_NUMBER_OFFSET + MESSAGE_NUMBER_SIZE;
+
+    static const int MESSAGE_PART_NUMBER_OFFSET = 0;
+
+    // Masks
+    static const uint32_t CONTROL_BIT_MASK = uint32_t(0b1) << CONTROL_BIT_OFFSET;
+    static const uint32_t RELIABILITY_BIT_MASK = uint32_t(0b1) << RELIABILITY_BIT_OFFSET;
+    static const uint32_t MESSAGE_BIT_MASK = uint32_t(0b1) << MESSAGE_BIT_OFFSET;
+    static const uint32_t OBFUSCATION_LEVEL_MASK = uint32_t(0b11) << OBFUSCATION_LEVEL_OFFSET;
+    static const uint32_t BIT_FIELD_MASK = CONTROL_BIT_MASK | RELIABILITY_BIT_MASK | MESSAGE_BIT_MASK | OBFUSCATION_LEVEL_MASK;
+    static const uint32_t SEQUENCE_NUMBER_MASK = ~BIT_FIELD_MASK;
+
+    static const uint32_t PACKET_POSITION_MASK = uint32_t(0b11) << PACKET_POSITION_OFFSET;
+    static const uint32_t MESSAGE_NUMBER_MASK = ~PACKET_POSITION_MASK;
+
+    static const uint32_t MESSAGE_PART_NUMBER_MASK = ~uint32_t(0);
+
+    // Static checks
+    static_assert(CONTROL_BIT_SIZE + RELIABILITY_BIT_SIZE + MESSAGE_BIT_SIZE +
+                  OBFUSCATION_LEVEL_SIZE + SEQUENCE_NUMBER_SIZE == 32, "Sequence number line size incorrect");
+    static_assert(PACKET_POSITION_SIZE + MESSAGE_NUMBER_SIZE == 32, "Message number line size incorrect");
+    static_assert(MESSAGE_PART_NUMBER_SIZE  == 32, "Message part number line size incorrect");
+
+    static_assert(CONTROL_BIT_MASK         == 0b10000000000000000000000000000000, "CONTROL_BIT_MASK incorrect");
+    static_assert(RELIABILITY_BIT_MASK     == 0b01000000000000000000000000000000, "RELIABILITY_BIT_MASK incorrect");
+    static_assert(MESSAGE_BIT_MASK         == 0b00100000000000000000000000000000, "MESSAGE_BIT_MASK incorrect");
+    static_assert(OBFUSCATION_LEVEL_MASK   == 0b00011000000000000000000000000000, "OBFUSCATION_LEVEL_MASK incorrect");
+    static_assert(BIT_FIELD_MASK           == 0b11111000000000000000000000000000, "BIT_FIELD_MASK incorrect");
+    static_assert(SEQUENCE_NUMBER_MASK     == 0b00000111111111111111111111111111, "SEQUENCE_NUMBER_MASK incorrect");
+
+    static_assert(PACKET_POSITION_MASK     == 0b11000000000000000000000000000000, "PACKET_POSITION_MASK incorrect");
+    static_assert(MESSAGE_NUMBER_MASK      == 0b00111111111111111111111111111111, "MESSAGE_NUMBER_MASK incorrect");
+
+    static_assert(MESSAGE_PART_NUMBER_MASK == 0b11111111111111111111111111111111, "MESSAGE_PART_NUMBER_MASK incorrect");
 }
 
 #endif // hifi_udt_Constants_h
diff --git a/libraries/networking/src/udt/Packet.cpp b/libraries/networking/src/udt/Packet.cpp
index 53b6ef5b68..17d18bebea 100644
--- a/libraries/networking/src/udt/Packet.cpp
+++ b/libraries/networking/src/udt/Packet.cpp
@@ -120,20 +120,11 @@ void Packet::writeMessageNumber(MessageNumber messageNumber, PacketPosition posi
 }
 
 void Packet::writeSequenceNumber(SequenceNumber sequenceNumber, ObfuscationLevel level) const {
-    _obfuscationLevel = level;
     _sequenceNumber = sequenceNumber;
+    _obfuscationLevel = level;
     writeHeader();
 }
 
-static const uint32_t RELIABILITY_BIT_MASK = uint32_t(1) << (SEQUENCE_NUMBER_BITS - 2);
-static const uint32_t MESSAGE_BIT_MASK = uint32_t(1) << (SEQUENCE_NUMBER_BITS - 3);
-static const uint32_t OBFUSCATION_LEVEL_MASK = uint32_t(0x03) << (SEQUENCE_NUMBER_BITS - 5);
-static const uint32_t BIT_FIELD_MASK = CONTROL_BIT_MASK | RELIABILITY_BIT_MASK | MESSAGE_BIT_MASK | OBFUSCATION_LEVEL_MASK;
-
-static const uint8_t PACKET_POSITION_OFFSET = 30;
-static const uint32_t PACKET_POSITION_MASK = uint32_t(0x03) << PACKET_POSITION_OFFSET;
-static const uint32_t MESSAGE_NUMBER_MASK = ~PACKET_POSITION_MASK;
-
 void Packet::readHeader() const {
     SequenceNumberAndBitField* seqNumBitField = reinterpret_cast<SequenceNumberAndBitField*>(_packet.get());
     
@@ -141,8 +132,8 @@ void Packet::readHeader() const {
     
     _isReliable = (bool) (*seqNumBitField & RELIABILITY_BIT_MASK); // Only keep reliability bit
     _isPartOfMessage = (bool) (*seqNumBitField & MESSAGE_BIT_MASK); // Only keep message bit
-    _obfuscationLevel = (ObfuscationLevel)((*seqNumBitField & OBFUSCATION_LEVEL_MASK) >> (SEQUENCE_NUMBER_BITS - 5));
-    _sequenceNumber = SequenceNumber{ *seqNumBitField & ~BIT_FIELD_MASK }; // Remove the bit field
+    _obfuscationLevel = (ObfuscationLevel)((*seqNumBitField & OBFUSCATION_LEVEL_MASK) >> OBFUSCATION_LEVEL_OFFSET);
+    _sequenceNumber = SequenceNumber{ *seqNumBitField & SEQUENCE_NUMBER_MASK }; // Remove the bit field
 
     if (_isPartOfMessage) {
         MessageNumberAndBitField* messageNumberAndBitField = seqNumBitField + 1;
@@ -168,7 +159,7 @@ void Packet::writeHeader() const {
     }
 
     if (_obfuscationLevel != NoObfuscation) {
-        *seqNumBitField |= (_obfuscationLevel << (SEQUENCE_NUMBER_BITS - 5));
+        *seqNumBitField |= (_obfuscationLevel << OBFUSCATION_LEVEL_OFFSET);
     }
     
     if (_isPartOfMessage) {
diff --git a/libraries/networking/src/udt/Packet.h b/libraries/networking/src/udt/Packet.h
index 3eefa83edc..2fd38de51f 100644
--- a/libraries/networking/src/udt/Packet.h
+++ b/libraries/networking/src/udt/Packet.h
@@ -65,7 +65,7 @@ public:
         NoObfuscation = 0x0, // 00
         ObfuscationL1 = 0x1, // 01
         ObfuscationL2 = 0x2, // 10
-        ObfuscationL3 = 0x3, // 01
+        ObfuscationL3 = 0x3, // 11
     };
 
     static std::unique_ptr<Packet> create(qint64 size = -1, bool isReliable = false, bool isPartOfMessage = false);
diff --git a/libraries/networking/src/udt/PacketQueue.cpp b/libraries/networking/src/udt/PacketQueue.cpp
index bc3a1796e2..8ff2333a20 100644
--- a/libraries/networking/src/udt/PacketQueue.cpp
+++ b/libraries/networking/src/udt/PacketQueue.cpp
@@ -16,7 +16,7 @@
 using namespace udt;
 
 MessageNumber PacketQueue::getNextMessageNumber() {
-    static const MessageNumber MAX_MESSAGE_NUMBER = MessageNumber(1) << MESSAGE_NUMBER_BITS;
+    static const MessageNumber MAX_MESSAGE_NUMBER = MessageNumber(1) << MESSAGE_NUMBER_SIZE;
     _currentMessageNumber = (_currentMessageNumber + 1) % MAX_MESSAGE_NUMBER;
     return _currentMessageNumber;
 }