diff --git a/internal/wire/ack_frame.go b/internal/wire/ack_frame.go
index e6870baac..e2e8f471f 100644
--- a/internal/wire/ack_frame.go
+++ b/internal/wire/ack_frame.go
@@ -102,7 +102,7 @@ func parseAckFrame(r *bytes.Reader, version protocol.VersionNumber) (*AckFrame,
 
 // Write writes an ACK frame.
 func (f *AckFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error {
-	b.WriteByte(0x1a)
+	b.WriteByte(0x2)
 	utils.WriteVarInt(b, uint64(f.LargestAcked()))
 	utils.WriteVarInt(b, encodeAckDelay(f.DelayTime))
 
diff --git a/internal/wire/ack_frame_test.go b/internal/wire/ack_frame_test.go
index bdcc5a953..65a06feeb 100644
--- a/internal/wire/ack_frame_test.go
+++ b/internal/wire/ack_frame_test.go
@@ -13,7 +13,7 @@ import (
 var _ = Describe("ACK Frame (for IETF QUIC)", func() {
 	Context("parsing", func() {
 		It("parses an ACK frame without any ranges", func() {
-			data := []byte{0x1a}
+			data := []byte{0x2}
 			data = append(data, encodeVarInt(100)...) // largest acked
 			data = append(data, encodeVarInt(0)...)   // delay
 			data = append(data, encodeVarInt(0)...)   // num blocks
@@ -28,7 +28,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() {
 		})
 
 		It("parses an ACK frame that only acks a single packet", func() {
-			data := []byte{0x1a}
+			data := []byte{0x2}
 			data = append(data, encodeVarInt(55)...) // largest acked
 			data = append(data, encodeVarInt(0)...)  // delay
 			data = append(data, encodeVarInt(0)...)  // num blocks
@@ -43,7 +43,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() {
 		})
 
 		It("accepts an ACK frame that acks all packets from 0 to largest", func() {
-			data := []byte{0x1a}
+			data := []byte{0x2}
 			data = append(data, encodeVarInt(20)...) // largest acked
 			data = append(data, encodeVarInt(0)...)  // delay
 			data = append(data, encodeVarInt(0)...)  // num blocks
@@ -58,7 +58,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() {
 		})
 
 		It("rejects an ACK frame that has a first ACK block which is larger than LargestAcked", func() {
-			data := []byte{0x1a}
+			data := []byte{0x2}
 			data = append(data, encodeVarInt(20)...) // largest acked
 			data = append(data, encodeVarInt(0)...)  // delay
 			data = append(data, encodeVarInt(0)...)  // num blocks
@@ -69,7 +69,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() {
 		})
 
 		It("parses an ACK frame that has a single block", func() {
-			data := []byte{0x1a}
+			data := []byte{0x2}
 			data = append(data, encodeVarInt(1000)...) // largest acked
 			data = append(data, encodeVarInt(0)...)    // delay
 			data = append(data, encodeVarInt(1)...)    // num blocks
@@ -90,7 +90,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() {
 		})
 
 		It("parses an ACK frame that has a multiple blocks", func() {
-			data := []byte{0x1a}
+			data := []byte{0x2}
 			data = append(data, encodeVarInt(100)...) // largest acked
 			data = append(data, encodeVarInt(0)...)   // delay
 			data = append(data, encodeVarInt(2)...)   // num blocks
@@ -114,7 +114,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() {
 		})
 
 		It("errors on EOF", func() {
-			data := []byte{0x1a}
+			data := []byte{0x2}
 			data = append(data, encodeVarInt(1000)...) // largest acked
 			data = append(data, encodeVarInt(0)...)    // delay
 			data = append(data, encodeVarInt(1)...)    // num blocks
@@ -131,7 +131,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() {
 
 		Context("ACK_ECN", func() {
 			It("parses", func() {
-				data := []byte{0x1b}
+				data := []byte{0x3}
 				data = append(data, encodeVarInt(100)...)        // largest acked
 				data = append(data, encodeVarInt(0)...)          // delay
 				data = append(data, encodeVarInt(0)...)          // num blocks
@@ -149,7 +149,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() {
 			})
 
 			It("errors on EOF", func() {
-				data := []byte{0x1b}
+				data := []byte{0x3}
 				data = append(data, encodeVarInt(1000)...)       // largest acked
 				data = append(data, encodeVarInt(0)...)          // delay
 				data = append(data, encodeVarInt(1)...)          // num blocks
@@ -178,7 +178,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() {
 			}
 			err := f.Write(buf, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x1a}
+			expected := []byte{0x2}
 			expected = append(expected, encodeVarInt(1337)...) // largest acked
 			expected = append(expected, 0)                     // delay
 			expected = append(expected, encodeVarInt(0)...)    // num ranges
@@ -189,7 +189,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() {
 		It("writes a frame that acks a single packet", func() {
 			buf := &bytes.Buffer{}
 			f := &AckFrame{
-				AckRanges: []AckRange{{Smallest: 0x1aeadbeef, Largest: 0x1aeadbeef}},
+				AckRanges: []AckRange{{Smallest: 0x2eadbeef, Largest: 0x2eadbeef}},
 				DelayTime: 18 * time.Millisecond,
 			}
 			err := f.Write(buf, versionIETFFrames)
@@ -207,7 +207,7 @@ var _ = Describe("ACK Frame (for IETF QUIC)", func() {
 		It("writes a frame that acks many packets", func() {
 			buf := &bytes.Buffer{}
 			f := &AckFrame{
-				AckRanges: []AckRange{{Smallest: 0x1337, Largest: 0x1aeadbeef}},
+				AckRanges: []AckRange{{Smallest: 0x1337, Largest: 0x2eadbeef}},
 			}
 			err := f.Write(buf, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
diff --git a/internal/wire/connection_close_frame.go b/internal/wire/connection_close_frame.go
index 4f523474a..60378a5d8 100644
--- a/internal/wire/connection_close_frame.go
+++ b/internal/wire/connection_close_frame.go
@@ -16,14 +16,13 @@ type ConnectionCloseFrame struct {
 	ReasonPhrase       string
 }
 
-// parseConnectionCloseFrame reads a CONNECTION_CLOSE frame
 func parseConnectionCloseFrame(r *bytes.Reader, version protocol.VersionNumber) (*ConnectionCloseFrame, error) {
 	typeByte, err := r.ReadByte()
 	if err != nil {
 		return nil, err
 	}
 
-	f := &ConnectionCloseFrame{IsApplicationError: typeByte == 0x03}
+	f := &ConnectionCloseFrame{IsApplicationError: typeByte == 0x1d}
 	ec, err := utils.BigEndian.ReadUint16(r)
 	if err != nil {
 		return nil, err
@@ -65,12 +64,11 @@ func (f *ConnectionCloseFrame) Length(version protocol.VersionNumber) protocol.B
 	return length
 }
 
-// Write writes an CONNECTION_CLOSE frame.
 func (f *ConnectionCloseFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error {
 	if f.IsApplicationError {
-		b.WriteByte(0x03)
+		b.WriteByte(0x1d)
 	} else {
-		b.WriteByte(0x02)
+		b.WriteByte(0x1c)
 	}
 
 	utils.BigEndian.WriteUint16(b, uint16(f.ErrorCode))
diff --git a/internal/wire/connection_close_frame_test.go b/internal/wire/connection_close_frame_test.go
index 5a36653fd..0093da442 100644
--- a/internal/wire/connection_close_frame_test.go
+++ b/internal/wire/connection_close_frame_test.go
@@ -6,6 +6,7 @@ import (
 
 	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/qerr"
+
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -14,7 +15,7 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() {
 	Context("when parsing", func() {
 		It("accepts sample frame containing a QUIC error code", func() {
 			reason := "No recent network activity."
-			data := []byte{0x2, 0x0, 0x19}
+			data := []byte{0x1c, 0x0, 0x19}
 			data = append(data, encodeVarInt(0x1337)...)              // frame type
 			data = append(data, encodeVarInt(uint64(len(reason)))...) // reason phrase length
 			data = append(data, []byte(reason)...)
@@ -29,7 +30,7 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() {
 
 		It("accepts sample frame containing an application error code", func() {
 			reason := "The application messed things up."
-			data := []byte{0x3, 0x0, 0x19}
+			data := []byte{0x1d, 0x0, 0x19}
 			data = append(data, encodeVarInt(uint64(len(reason)))...) // reason phrase length
 			data = append(data, reason...)
 			b := bytes.NewReader(data)
@@ -42,7 +43,7 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() {
 		})
 
 		It("rejects long reason phrases", func() {
-			data := []byte{0x2, 0xca, 0xfe}
+			data := []byte{0x1c, 0xca, 0xfe}
 			data = append(data, encodeVarInt(0x42)...)   // frame type
 			data = append(data, encodeVarInt(0xffff)...) // reason phrase length
 			b := bytes.NewReader(data)
@@ -52,7 +53,7 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() {
 
 		It("errors on EOFs", func() {
 			reason := "No recent network activity."
-			data := []byte{0x2, 0x0, 0x19}
+			data := []byte{0x1c, 0x0, 0x19}
 			data = append(data, encodeVarInt(0x1337)...)              // frame type
 			data = append(data, encodeVarInt(uint64(len(reason)))...) // reason phrase length
 			data = append(data, []byte(reason)...)
@@ -65,7 +66,7 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() {
 		})
 
 		It("parses a frame without a reason phrase", func() {
-			data := []byte{0x2, 0xca, 0xfe}
+			data := []byte{0x1c, 0xca, 0xfe}
 			data = append(data, encodeVarInt(0x42)...) // frame type
 			data = append(data, encodeVarInt(0)...)
 			b := bytes.NewReader(data)
@@ -77,20 +78,20 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() {
 	})
 
 	Context("when writing", func() {
-		It("writes a frame without a ReasonPhrase", func() {
+		It("writes a frame without a reason phrase", func() {
 			b := &bytes.Buffer{}
 			frame := &ConnectionCloseFrame{
 				ErrorCode: 0xbeef,
 			}
 			err := frame.Write(b, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x2, 0xbe, 0xef}
+			expected := []byte{0x1c, 0xbe, 0xef}
 			expected = append(expected, encodeVarInt(0)...) // frame type
 			expected = append(expected, encodeVarInt(0)...) // reason phrase length
 			Expect(b.Bytes()).To(Equal(expected))
 		})
 
-		It("writes a frame with a ReasonPhrase", func() {
+		It("writes a frame with a reason phrase", func() {
 			b := &bytes.Buffer{}
 			frame := &ConnectionCloseFrame{
 				ErrorCode:    0xdead,
@@ -98,7 +99,7 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() {
 			}
 			err := frame.Write(b, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x2, 0xde, 0xad}
+			expected := []byte{0x1c, 0xde, 0xad}
 			expected = append(expected, encodeVarInt(0)...) // frame type
 			expected = append(expected, encodeVarInt(6)...) // reason phrase length
 			expected = append(expected, []byte("foobar")...)
@@ -114,7 +115,7 @@ var _ = Describe("CONNECTION_CLOSE Frame", func() {
 			}
 			err := frame.Write(b, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x3, 0xde, 0xad}
+			expected := []byte{0x1d, 0xde, 0xad}
 			expected = append(expected, encodeVarInt(6)...) // reason phrase length
 			expected = append(expected, []byte("foobar")...)
 			Expect(b.Bytes()).To(Equal(expected))
diff --git a/internal/wire/crypto_frame.go b/internal/wire/crypto_frame.go
index 264ac5f3a..eeafea974 100644
--- a/internal/wire/crypto_frame.go
+++ b/internal/wire/crypto_frame.go
@@ -43,7 +43,7 @@ func parseCryptoFrame(r *bytes.Reader, _ protocol.VersionNumber) (*CryptoFrame,
 }
 
 func (f *CryptoFrame) Write(b *bytes.Buffer, _ protocol.VersionNumber) error {
-	b.WriteByte(0x18)
+	b.WriteByte(0x6)
 	utils.WriteVarInt(b, uint64(f.Offset))
 	utils.WriteVarInt(b, uint64(len(f.Data)))
 	b.Write(f.Data)
diff --git a/internal/wire/crypto_frame_test.go b/internal/wire/crypto_frame_test.go
index 492ec1ce6..b2b19cfa2 100644
--- a/internal/wire/crypto_frame_test.go
+++ b/internal/wire/crypto_frame_test.go
@@ -12,7 +12,7 @@ import (
 var _ = Describe("CRYPTO frame", func() {
 	Context("when parsing", func() {
 		It("parses", func() {
-			data := []byte{0x18}
+			data := []byte{0x6}
 			data = append(data, encodeVarInt(0xdecafbad)...) // offset
 			data = append(data, encodeVarInt(6)...)          // length
 			data = append(data, []byte("foobar")...)
@@ -25,7 +25,7 @@ var _ = Describe("CRYPTO frame", func() {
 		})
 
 		It("errors on EOFs", func() {
-			data := []byte{0x18}
+			data := []byte{0x6}
 			data = append(data, encodeVarInt(0xdecafbad)...) // offset
 			data = append(data, encodeVarInt(6)...)          // data length
 			data = append(data, []byte("foobar")...)
@@ -47,7 +47,7 @@ var _ = Describe("CRYPTO frame", func() {
 			b := &bytes.Buffer{}
 			err := f.Write(b, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x18}
+			expected := []byte{0x6}
 			expected = append(expected, encodeVarInt(0x123456)...) // offset
 			expected = append(expected, encodeVarInt(6)...)        // length
 			expected = append(expected, []byte("foobar")...)
diff --git a/internal/wire/data_blocked_frame.go b/internal/wire/data_blocked_frame.go
index 6208a2d23..91c05ccfb 100644
--- a/internal/wire/data_blocked_frame.go
+++ b/internal/wire/data_blocked_frame.go
@@ -26,7 +26,7 @@ func parseDataBlockedFrame(r *bytes.Reader, _ protocol.VersionNumber) (*DataBloc
 }
 
 func (f *DataBlockedFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error {
-	typeByte := uint8(0x08)
+	typeByte := uint8(0x14)
 	b.WriteByte(typeByte)
 	utils.WriteVarInt(b, uint64(f.DataLimit))
 	return nil
diff --git a/internal/wire/data_blocked_frame_test.go b/internal/wire/data_blocked_frame_test.go
index d3957ce88..ac3588a15 100644
--- a/internal/wire/data_blocked_frame_test.go
+++ b/internal/wire/data_blocked_frame_test.go
@@ -14,7 +14,7 @@ import (
 var _ = Describe("DATA_BLOCKED frame", func() {
 	Context("when parsing", func() {
 		It("accepts sample frame", func() {
-			data := []byte{0x08}
+			data := []byte{0x14}
 			data = append(data, encodeVarInt(0x12345678)...)
 			b := bytes.NewReader(data)
 			frame, err := parseDataBlockedFrame(b, versionIETFFrames)
@@ -24,7 +24,7 @@ var _ = Describe("DATA_BLOCKED frame", func() {
 		})
 
 		It("errors on EOFs", func() {
-			data := []byte{0x08}
+			data := []byte{0x14}
 			data = append(data, encodeVarInt(0x12345678)...)
 			_, err := parseDataBlockedFrame(bytes.NewReader(data), versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
@@ -41,7 +41,7 @@ var _ = Describe("DATA_BLOCKED frame", func() {
 			frame := DataBlockedFrame{DataLimit: 0xdeadbeef}
 			err := frame.Write(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x08}
+			expected := []byte{0x14}
 			expected = append(expected, encodeVarInt(0xdeadbeef)...)
 			Expect(b.Bytes()).To(Equal(expected))
 		})
diff --git a/internal/wire/frame_parser.go b/internal/wire/frame_parser.go
index 91008bdd6..bd4848b9b 100644
--- a/internal/wire/frame_parser.go
+++ b/internal/wire/frame_parser.go
@@ -26,84 +26,50 @@ func ParseNextFrame(r *bytes.Reader, v protocol.VersionNumber) (Frame, error) {
 func parseFrame(r *bytes.Reader, typeByte byte, v protocol.VersionNumber) (Frame, error) {
 	var frame Frame
 	var err error
-	if typeByte&0xf8 == 0x10 {
+	if typeByte&0xf8 == 0x8 {
 		frame, err = parseStreamFrame(r, v)
 		if err != nil {
-			err = qerr.Error(qerr.InvalidStreamData, err.Error())
+			return nil, qerr.Error(qerr.InvalidFrameData, err.Error())
 		}
-		return frame, err
+		return frame, nil
 	}
-	// TODO: implement all IETF QUIC frame types
 	switch typeByte {
 	case 0x1:
-		frame, err = parseResetStreamFrame(r, v)
-		if err != nil {
-			err = qerr.Error(qerr.InvalidRstStreamData, err.Error())
-		}
-	case 0x2, 0x3:
-		frame, err = parseConnectionCloseFrame(r, v)
-		if err != nil {
-			err = qerr.Error(qerr.InvalidConnectionCloseData, err.Error())
-		}
-	case 0x4:
-		frame, err = parseMaxDataFrame(r, v)
-		if err != nil {
-			err = qerr.Error(qerr.InvalidWindowUpdateData, err.Error())
-		}
-	case 0x5:
-		frame, err = parseMaxStreamDataFrame(r, v)
-		if err != nil {
-			err = qerr.Error(qerr.InvalidWindowUpdateData, err.Error())
-		}
-	case 0x7:
 		frame, err = parsePingFrame(r, v)
-	case 0x8:
-		frame, err = parseDataBlockedFrame(r, v)
-		if err != nil {
-			err = qerr.Error(qerr.InvalidBlockedData, err.Error())
-		}
-	case 0x9:
-		frame, err = parseStreamDataBlockedFrame(r, v)
-		if err != nil {
-			err = qerr.Error(qerr.InvalidBlockedData, err.Error())
-		}
-	case 0xa, 0xb:
-		frame, err = parseStreamsBlockedFrame(r, v)
-		if err != nil {
-			err = qerr.Error(qerr.InvalidFrameData, err.Error())
-		}
-	case 0xc:
-		frame, err = parseStopSendingFrame(r, v)
-		if err != nil {
-			err = qerr.Error(qerr.InvalidFrameData, err.Error())
-		}
-	case 0xe:
-		frame, err = parsePathChallengeFrame(r, v)
-		if err != nil {
-			err = qerr.Error(qerr.InvalidFrameData, err.Error())
-		}
-	case 0xf:
-		frame, err = parsePathResponseFrame(r, v)
-		if err != nil {
-			err = qerr.Error(qerr.InvalidFrameData, err.Error())
-		}
-	case 0x1a, 0x1b:
+	case 0x2, 0x3:
 		frame, err = parseAckFrame(r, v)
-		if err != nil {
-			err = qerr.Error(qerr.InvalidAckData, err.Error())
-		}
-	case 0x1c, 0x1d:
-		frame, err = parseMaxStreamsFrame(r, v)
-		if err != nil {
-			err = qerr.Error(qerr.InvalidFrameData, err.Error())
-		}
-	case 0x18:
+	case 0x4:
+		frame, err = parseResetStreamFrame(r, v)
+	case 0x5:
+		frame, err = parseStopSendingFrame(r, v)
+	case 0x6:
 		frame, err = parseCryptoFrame(r, v)
-		if err != nil {
-			err = qerr.Error(qerr.InvalidFrameData, err.Error())
-		}
+	// TODO: implement the NEW_TOKEN frame
+	case 0x10:
+		frame, err = parseMaxDataFrame(r, v)
+	case 0x11:
+		frame, err = parseMaxStreamDataFrame(r, v)
+	case 0x12, 0x13:
+		frame, err = parseMaxStreamsFrame(r, v)
+	case 0x14:
+		frame, err = parseDataBlockedFrame(r, v)
+	case 0x15:
+		frame, err = parseStreamDataBlockedFrame(r, v)
+	case 0x16, 0x17:
+		frame, err = parseStreamsBlockedFrame(r, v)
+	// TODO: implement NEW_CONNECTION_ID frame
+	// TODO: implement RETIRE_CONNECTION_ID frame
+	case 0x1a:
+		frame, err = parsePathChallengeFrame(r, v)
+	case 0x1b:
+		frame, err = parsePathResponseFrame(r, v)
+	case 0x1c, 0x1d:
+		frame, err = parseConnectionCloseFrame(r, v)
 	default:
-		err = qerr.Error(qerr.InvalidFrameData, fmt.Sprintf("unknown type byte 0x%x", typeByte))
+		err = fmt.Errorf("unknown type byte 0x%x", typeByte)
 	}
-	return frame, err
+	if err != nil {
+		return nil, qerr.Error(qerr.InvalidFrameData, err.Error())
+	}
+	return frame, nil
 }
diff --git a/internal/wire/frame_parser_test.go b/internal/wire/frame_parser_test.go
index f3cec455e..b8f0abcb9 100644
--- a/internal/wire/frame_parser_test.go
+++ b/internal/wire/frame_parser_test.go
@@ -38,6 +38,17 @@ var _ = Describe("Frame parsing", func() {
 		Expect(r.Len()).To(BeZero())
 	})
 
+	It("unpacks ACK frames", func() {
+		f := &AckFrame{AckRanges: []AckRange{{Smallest: 1, Largest: 0x13}}}
+		err := f.Write(buf, versionIETFFrames)
+		Expect(err).ToNot(HaveOccurred())
+		frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), versionIETFFrames)
+		Expect(err).ToNot(HaveOccurred())
+		Expect(frame).ToNot(BeNil())
+		Expect(frame).To(BeAssignableToTypeOf(f))
+		Expect(frame.(*AckFrame).LargestAcked()).To(Equal(protocol.PacketNumber(0x13)))
+	})
+
 	It("unpacks RESET_STREAM frames", func() {
 		f := &ResetStreamFrame{
 			StreamID:   0xdeadbeef,
@@ -51,8 +62,9 @@ var _ = Describe("Frame parsing", func() {
 		Expect(frame).To(Equal(f))
 	})
 
-	It("unpacks CONNECTION_CLOSE frames containing QUIC error codes", func() {
-		f := &ConnectionCloseFrame{ReasonPhrase: "foo"}
+	It("unpacks STOP_SENDING frames", func() {
+		f := &StopSendingFrame{StreamID: 0x42}
+		buf := &bytes.Buffer{}
 		err := f.Write(buf, versionIETFFrames)
 		Expect(err).ToNot(HaveOccurred())
 		frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), versionIETFFrames)
@@ -60,15 +72,31 @@ var _ = Describe("Frame parsing", func() {
 		Expect(frame).To(Equal(f))
 	})
 
-	It("unpacks CONNECTION_CLOSE frames containing application error codes", func() {
-		f := &ConnectionCloseFrame{
-			IsApplicationError: true,
-			ReasonPhrase:       "foo",
+	It("unpacks CRYPTO frames", func() {
+		f := &CryptoFrame{
+			Offset: 0x1337,
+			Data:   []byte("lorem ipsum"),
 		}
 		err := f.Write(buf, versionIETFFrames)
 		Expect(err).ToNot(HaveOccurred())
 		frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), versionIETFFrames)
 		Expect(err).ToNot(HaveOccurred())
+		Expect(frame).ToNot(BeNil())
+		Expect(frame).To(Equal(f))
+	})
+
+	It("unpacks STREAM frames", func() {
+		f := &StreamFrame{
+			StreamID: 0x42,
+			Offset:   0x1337,
+			FinBit:   true,
+			Data:     []byte("foobar"),
+		}
+		err := f.Write(buf, versionIETFFrames)
+		Expect(err).ToNot(HaveOccurred())
+		frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), versionIETFFrames)
+		Expect(err).ToNot(HaveOccurred())
+		Expect(frame).ToNot(BeNil())
 		Expect(frame).To(Equal(f))
 	})
 
@@ -125,7 +153,6 @@ var _ = Describe("Frame parsing", func() {
 			StreamID:  0xdeadbeef,
 			DataLimit: 0xdead,
 		}
-		buf := &bytes.Buffer{}
 		err := f.Write(buf, versionIETFFrames)
 		Expect(err).ToNot(HaveOccurred())
 		frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), versionIETFFrames)
@@ -146,27 +173,6 @@ var _ = Describe("Frame parsing", func() {
 		Expect(frame).To(Equal(f))
 	})
 
-	It("unpacks STOP_SENDING frames", func() {
-		f := &StopSendingFrame{StreamID: 0x42}
-		buf := &bytes.Buffer{}
-		err := f.Write(buf, versionIETFFrames)
-		Expect(err).ToNot(HaveOccurred())
-		frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), versionIETFFrames)
-		Expect(err).ToNot(HaveOccurred())
-		Expect(frame).To(Equal(f))
-	})
-
-	It("unpacks ACK frames", func() {
-		f := &AckFrame{AckRanges: []AckRange{{Smallest: 1, Largest: 0x13}}}
-		err := f.Write(buf, versionIETFFrames)
-		Expect(err).ToNot(HaveOccurred())
-		frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), versionIETFFrames)
-		Expect(err).ToNot(HaveOccurred())
-		Expect(frame).ToNot(BeNil())
-		Expect(frame).To(BeAssignableToTypeOf(f))
-		Expect(frame.(*AckFrame).LargestAcked()).To(Equal(protocol.PacketNumber(0x13)))
-	})
-
 	It("unpacks PATH_CHALLENGE frames", func() {
 		f := &PathChallengeFrame{Data: [8]byte{1, 2, 3, 4, 5, 6, 7, 8}}
 		err := f.Write(buf, versionIETFFrames)
@@ -189,16 +195,16 @@ var _ = Describe("Frame parsing", func() {
 		Expect(frame.(*PathResponseFrame).Data).To(Equal([8]byte{1, 2, 3, 4, 5, 6, 7, 8}))
 	})
 
-	It("unpacks CRYPTO frames", func() {
-		f := &CryptoFrame{
-			Offset: 0x1337,
-			Data:   []byte("lorem ipsum"),
+	It("unpacks CONNECTION_CLOSE frames", func() {
+		f := &ConnectionCloseFrame{
+			IsApplicationError: true,
+			ReasonPhrase:       "foobar",
 		}
+		buf := &bytes.Buffer{}
 		err := f.Write(buf, versionIETFFrames)
 		Expect(err).ToNot(HaveOccurred())
 		frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), versionIETFFrames)
 		Expect(err).ToNot(HaveOccurred())
-		Expect(frame).ToNot(BeNil())
 		Expect(frame).To(Equal(f))
 	})
 
@@ -208,25 +214,14 @@ var _ = Describe("Frame parsing", func() {
 	})
 
 	It("errors on invalid frames", func() {
-		for b, e := range map[byte]qerr.ErrorCode{
-			0x01: qerr.InvalidRstStreamData,
-			0x02: qerr.InvalidConnectionCloseData,
-			0x04: qerr.InvalidWindowUpdateData,
-			0x05: qerr.InvalidWindowUpdateData,
-			0x06: qerr.InvalidFrameData,
-			0x08: qerr.InvalidBlockedData,
-			0x09: qerr.InvalidBlockedData,
-			0x0a: qerr.InvalidFrameData,
-			0x0c: qerr.InvalidFrameData,
-			0x0e: qerr.InvalidFrameData,
-			0x0f: qerr.InvalidFrameData,
-			0x10: qerr.InvalidStreamData,
-			0x1a: qerr.InvalidAckData,
-			0x1b: qerr.InvalidAckData,
-		} {
-			_, err := ParseNextFrame(bytes.NewReader([]byte{b}), versionIETFFrames)
-			Expect(err).To(HaveOccurred())
-			Expect(err.(*qerr.QuicError).ErrorCode).To(Equal(e))
+		f := &MaxStreamDataFrame{
+			StreamID:   0x1337,
+			ByteOffset: 0xdeadbeef,
 		}
+		b := &bytes.Buffer{}
+		f.Write(b, versionIETFFrames)
+		_, err := ParseNextFrame(bytes.NewReader(b.Bytes()[:b.Len()-2]), versionIETFFrames)
+		Expect(err).To(HaveOccurred())
+		Expect(err.(*qerr.QuicError).ErrorCode).To(Equal(qerr.InvalidFrameData))
 	})
 })
diff --git a/internal/wire/max_data_frame.go b/internal/wire/max_data_frame.go
index 1fdfd940e..c4a9be0df 100644
--- a/internal/wire/max_data_frame.go
+++ b/internal/wire/max_data_frame.go
@@ -14,7 +14,6 @@ type MaxDataFrame struct {
 
 // parseMaxDataFrame parses a MAX_DATA frame
 func parseMaxDataFrame(r *bytes.Reader, version protocol.VersionNumber) (*MaxDataFrame, error) {
-	// read the TypeByte
 	if _, err := r.ReadByte(); err != nil {
 		return nil, err
 	}
@@ -30,7 +29,7 @@ func parseMaxDataFrame(r *bytes.Reader, version protocol.VersionNumber) (*MaxDat
 
 //Write writes a MAX_STREAM_DATA frame
 func (f *MaxDataFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error {
-	b.WriteByte(0x4)
+	b.WriteByte(0x10)
 	utils.WriteVarInt(b, uint64(f.ByteOffset))
 	return nil
 }
diff --git a/internal/wire/max_data_frame_test.go b/internal/wire/max_data_frame_test.go
index 0851bd751..86ead9171 100644
--- a/internal/wire/max_data_frame_test.go
+++ b/internal/wire/max_data_frame_test.go
@@ -12,7 +12,7 @@ import (
 var _ = Describe("MAX_DATA frame", func() {
 	Context("when parsing", func() {
 		It("accepts sample frame", func() {
-			data := []byte{0x4}
+			data := []byte{0x10}
 			data = append(data, encodeVarInt(0xdecafbad123456)...) // byte offset
 			b := bytes.NewReader(data)
 			frame, err := parseMaxDataFrame(b, versionIETFFrames)
@@ -22,7 +22,7 @@ var _ = Describe("MAX_DATA frame", func() {
 		})
 
 		It("errors on EOFs", func() {
-			data := []byte{0x4}
+			data := []byte{0x10}
 			data = append(data, encodeVarInt(0xdecafbad1234567)...) // byte offset
 			_, err := parseMaxDataFrame(bytes.NewReader(data), versionIETFFrames)
 			Expect(err).NotTo(HaveOccurred())
@@ -48,7 +48,7 @@ var _ = Describe("MAX_DATA frame", func() {
 			}
 			err := f.Write(b, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x4}
+			expected := []byte{0x10}
 			expected = append(expected, encodeVarInt(0xdeadbeefcafe)...)
 			Expect(b.Bytes()).To(Equal(expected))
 		})
diff --git a/internal/wire/max_stream_data_frame.go b/internal/wire/max_stream_data_frame.go
index d9a73aa65..2566f1c9b 100644
--- a/internal/wire/max_stream_data_frame.go
+++ b/internal/wire/max_stream_data_frame.go
@@ -7,17 +7,13 @@ import (
 	"github.com/lucas-clemente/quic-go/internal/utils"
 )
 
-// A MaxStreamDataFrame carries flow control information for a stream
+// A MaxStreamDataFrame is a MAX_STREAM_DATA frame
 type MaxStreamDataFrame struct {
 	StreamID   protocol.StreamID
 	ByteOffset protocol.ByteCount
 }
 
-// parseMaxStreamDataFrame parses a MAX_STREAM_DATA frame
 func parseMaxStreamDataFrame(r *bytes.Reader, version protocol.VersionNumber) (*MaxStreamDataFrame, error) {
-	frame := &MaxStreamDataFrame{}
-
-	// read the TypeByte
 	if _, err := r.ReadByte(); err != nil {
 		return nil, err
 	}
@@ -26,19 +22,19 @@ func parseMaxStreamDataFrame(r *bytes.Reader, version protocol.VersionNumber) (*
 	if err != nil {
 		return nil, err
 	}
-	frame.StreamID = protocol.StreamID(sid)
-
-	byteOffset, err := utils.ReadVarInt(r)
+	offset, err := utils.ReadVarInt(r)
 	if err != nil {
 		return nil, err
 	}
-	frame.ByteOffset = protocol.ByteCount(byteOffset)
-	return frame, nil
+
+	return &MaxStreamDataFrame{
+		StreamID:   protocol.StreamID(sid),
+		ByteOffset: protocol.ByteCount(offset),
+	}, nil
 }
 
-// Write writes a MAX_STREAM_DATA frame
 func (f *MaxStreamDataFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error {
-	b.WriteByte(0x5)
+	b.WriteByte(0x11)
 	utils.WriteVarInt(b, uint64(f.StreamID))
 	utils.WriteVarInt(b, uint64(f.ByteOffset))
 	return nil
diff --git a/internal/wire/max_stream_data_frame_test.go b/internal/wire/max_stream_data_frame_test.go
index 06f7c2456..3c1648508 100644
--- a/internal/wire/max_stream_data_frame_test.go
+++ b/internal/wire/max_stream_data_frame_test.go
@@ -12,7 +12,7 @@ import (
 var _ = Describe("MAX_STREAM_DATA frame", func() {
 	Context("parsing", func() {
 		It("accepts sample frame", func() {
-			data := []byte{0x5}
+			data := []byte{0x11}
 			data = append(data, encodeVarInt(0xdeadbeef)...) // Stream ID
 			data = append(data, encodeVarInt(0x12345678)...) // Offset
 			b := bytes.NewReader(data)
@@ -24,7 +24,7 @@ var _ = Describe("MAX_STREAM_DATA frame", func() {
 		})
 
 		It("errors on EOFs", func() {
-			data := []byte{0x5}
+			data := []byte{0x11}
 			data = append(data, encodeVarInt(0xdeadbeef)...) // Stream ID
 			data = append(data, encodeVarInt(0x12345678)...) // Offset
 			_, err := parseMaxStreamDataFrame(bytes.NewReader(data), versionIETFFrames)
@@ -51,7 +51,7 @@ var _ = Describe("MAX_STREAM_DATA frame", func() {
 				StreamID:   0xdecafbad,
 				ByteOffset: 0xdeadbeefcafe42,
 			}
-			expected := []byte{0x5}
+			expected := []byte{0x11}
 			expected = append(expected, encodeVarInt(0xdecafbad)...)
 			expected = append(expected, encodeVarInt(0xdeadbeefcafe42)...)
 			err := f.Write(b, versionIETFFrames)
diff --git a/internal/wire/max_streams_frame.go b/internal/wire/max_streams_frame.go
index 65bc38f3f..c7a3cd41c 100644
--- a/internal/wire/max_streams_frame.go
+++ b/internal/wire/max_streams_frame.go
@@ -21,9 +21,9 @@ func parseMaxStreamsFrame(r *bytes.Reader, _ protocol.VersionNumber) (*MaxStream
 
 	f := &MaxStreamsFrame{}
 	switch typeByte {
-	case 0x1c:
+	case 0x12:
 		f.Type = protocol.StreamTypeBidi
-	case 0x1d:
+	case 0x13:
 		f.Type = protocol.StreamTypeUni
 	}
 	streamID, err := utils.ReadVarInt(r)
@@ -37,9 +37,9 @@ func parseMaxStreamsFrame(r *bytes.Reader, _ protocol.VersionNumber) (*MaxStream
 func (f *MaxStreamsFrame) Write(b *bytes.Buffer, _ protocol.VersionNumber) error {
 	switch f.Type {
 	case protocol.StreamTypeBidi:
-		b.WriteByte(0x1c)
+		b.WriteByte(0x12)
 	case protocol.StreamTypeUni:
-		b.WriteByte(0x1d)
+		b.WriteByte(0x13)
 	}
 	utils.WriteVarInt(b, f.MaxStreams)
 	return nil
diff --git a/internal/wire/max_streams_frame_test.go b/internal/wire/max_streams_frame_test.go
index b2c324396..a2ee51ff7 100644
--- a/internal/wire/max_streams_frame_test.go
+++ b/internal/wire/max_streams_frame_test.go
@@ -12,7 +12,7 @@ import (
 var _ = Describe("MAX_STREAMS frame", func() {
 	Context("parsing", func() {
 		It("accepts a frame for a bidirectional stream", func() {
-			data := []byte{0x1c}
+			data := []byte{0x12}
 			data = append(data, encodeVarInt(0xdecaf)...)
 			b := bytes.NewReader(data)
 			f, err := parseMaxStreamsFrame(b, protocol.VersionWhatever)
@@ -23,7 +23,7 @@ var _ = Describe("MAX_STREAMS frame", func() {
 		})
 
 		It("accepts a frame for a bidirectional stream", func() {
-			data := []byte{0x1d}
+			data := []byte{0x13}
 			data = append(data, encodeVarInt(0xdecaf)...)
 			b := bytes.NewReader(data)
 			f, err := parseMaxStreamsFrame(b, protocol.VersionWhatever)
@@ -53,7 +53,7 @@ var _ = Describe("MAX_STREAMS frame", func() {
 			}
 			b := &bytes.Buffer{}
 			Expect(f.Write(b, protocol.VersionWhatever)).To(Succeed())
-			expected := []byte{0x1c}
+			expected := []byte{0x12}
 			expected = append(expected, encodeVarInt(0xdeadbeef)...)
 			Expect(b.Bytes()).To(Equal(expected))
 		})
@@ -65,7 +65,7 @@ var _ = Describe("MAX_STREAMS frame", func() {
 			}
 			b := &bytes.Buffer{}
 			Expect(f.Write(b, protocol.VersionWhatever)).To(Succeed())
-			expected := []byte{0x1d}
+			expected := []byte{0x13}
 			expected = append(expected, encodeVarInt(0xdecafbad)...)
 			Expect(b.Bytes()).To(Equal(expected))
 		})
diff --git a/internal/wire/path_challenge_frame.go b/internal/wire/path_challenge_frame.go
index f2a27d849..d35ee3b54 100644
--- a/internal/wire/path_challenge_frame.go
+++ b/internal/wire/path_challenge_frame.go
@@ -27,8 +27,7 @@ func parsePathChallengeFrame(r *bytes.Reader, version protocol.VersionNumber) (*
 }
 
 func (f *PathChallengeFrame) Write(b *bytes.Buffer, _ protocol.VersionNumber) error {
-	typeByte := uint8(0x0e)
-	b.WriteByte(typeByte)
+	b.WriteByte(0x1a)
 	b.Write(f.Data[:])
 	return nil
 }
diff --git a/internal/wire/path_challenge_frame_test.go b/internal/wire/path_challenge_frame_test.go
index bbfc71093..de1aa80a5 100644
--- a/internal/wire/path_challenge_frame_test.go
+++ b/internal/wire/path_challenge_frame_test.go
@@ -5,6 +5,7 @@ import (
 	"io"
 
 	"github.com/lucas-clemente/quic-go/internal/protocol"
+
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -12,7 +13,7 @@ import (
 var _ = Describe("PATH_CHALLENGE frame", func() {
 	Context("when parsing", func() {
 		It("accepts sample frame", func() {
-			b := bytes.NewReader([]byte{0x0e, 1, 2, 3, 4, 5, 6, 7, 8})
+			b := bytes.NewReader([]byte{0x1a, 1, 2, 3, 4, 5, 6, 7, 8})
 			f, err := parsePathChallengeFrame(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(b.Len()).To(BeZero())
@@ -20,7 +21,7 @@ var _ = Describe("PATH_CHALLENGE frame", func() {
 		})
 
 		It("errors on EOFs", func() {
-			data := []byte{0x0e, 1, 2, 3, 4, 5, 6, 7, 8}
+			data := []byte{0x1a, 1, 2, 3, 4, 5, 6, 7, 8}
 			_, err := parsePathChallengeFrame(bytes.NewReader(data), versionIETFFrames)
 			Expect(err).NotTo(HaveOccurred())
 			for i := range data {
@@ -36,7 +37,7 @@ var _ = Describe("PATH_CHALLENGE frame", func() {
 			frame := PathChallengeFrame{Data: [8]byte{0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0x13, 0x37}}
 			err := frame.Write(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
-			Expect(b.Bytes()).To(Equal([]byte{0x0e, 0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0x13, 0x37}))
+			Expect(b.Bytes()).To(Equal([]byte{0x1a, 0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0x13, 0x37}))
 		})
 
 		It("has the correct min length", func() {
diff --git a/internal/wire/path_response_frame.go b/internal/wire/path_response_frame.go
index 2ab2fcda9..20d8fd721 100644
--- a/internal/wire/path_response_frame.go
+++ b/internal/wire/path_response_frame.go
@@ -27,8 +27,7 @@ func parsePathResponseFrame(r *bytes.Reader, version protocol.VersionNumber) (*P
 }
 
 func (f *PathResponseFrame) Write(b *bytes.Buffer, _ protocol.VersionNumber) error {
-	typeByte := uint8(0x0f)
-	b.WriteByte(typeByte)
+	b.WriteByte(0x1b)
 	b.Write(f.Data[:])
 	return nil
 }
diff --git a/internal/wire/path_response_frame_test.go b/internal/wire/path_response_frame_test.go
index 14e45bed8..5ba78a76c 100644
--- a/internal/wire/path_response_frame_test.go
+++ b/internal/wire/path_response_frame_test.go
@@ -12,7 +12,7 @@ import (
 var _ = Describe("PATH_RESPONSE frame", func() {
 	Context("when parsing", func() {
 		It("accepts sample frame", func() {
-			b := bytes.NewReader([]byte{0x0f, 1, 2, 3, 4, 5, 6, 7, 8})
+			b := bytes.NewReader([]byte{0x1b, 1, 2, 3, 4, 5, 6, 7, 8})
 			f, err := parsePathResponseFrame(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(b.Len()).To(BeZero())
@@ -20,7 +20,7 @@ var _ = Describe("PATH_RESPONSE frame", func() {
 		})
 
 		It("errors on EOFs", func() {
-			data := []byte{0x0f, 1, 2, 3, 4, 5, 6, 7, 8}
+			data := []byte{0x1b, 1, 2, 3, 4, 5, 6, 7, 8}
 			_, err := parsePathResponseFrame(bytes.NewReader(data), versionIETFFrames)
 			Expect(err).NotTo(HaveOccurred())
 			for i := range data {
@@ -36,7 +36,7 @@ var _ = Describe("PATH_RESPONSE frame", func() {
 			frame := PathResponseFrame{Data: [8]byte{0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0x13, 0x37}}
 			err := frame.Write(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
-			Expect(b.Bytes()).To(Equal([]byte{0x0f, 0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0x13, 0x37}))
+			Expect(b.Bytes()).To(Equal([]byte{0x1b, 0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0x13, 0x37}))
 		})
 
 		It("has the correct min length", func() {
diff --git a/internal/wire/ping_frame.go b/internal/wire/ping_frame.go
index bc1dedac0..aed6857b5 100644
--- a/internal/wire/ping_frame.go
+++ b/internal/wire/ping_frame.go
@@ -6,24 +6,18 @@ import (
 	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// A PingFrame is a ping frame
+// A PingFrame is a PING frame
 type PingFrame struct{}
 
-// parsePingFrame parses a Ping frame
 func parsePingFrame(r *bytes.Reader, version protocol.VersionNumber) (*PingFrame, error) {
-	frame := &PingFrame{}
-
-	_, err := r.ReadByte()
-	if err != nil {
+	if _, err := r.ReadByte(); err != nil {
 		return nil, err
 	}
-
-	return frame, nil
+	return &PingFrame{}, nil
 }
 
 func (f *PingFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error {
-	typeByte := uint8(0x07)
-	b.WriteByte(typeByte)
+	b.WriteByte(0x1)
 	return nil
 }
 
diff --git a/internal/wire/ping_frame_test.go b/internal/wire/ping_frame_test.go
index 54c7c6c16..d43efe346 100644
--- a/internal/wire/ping_frame_test.go
+++ b/internal/wire/ping_frame_test.go
@@ -11,7 +11,7 @@ import (
 var _ = Describe("PingFrame", func() {
 	Context("when parsing", func() {
 		It("accepts sample frame", func() {
-			b := bytes.NewReader([]byte{0x07})
+			b := bytes.NewReader([]byte{0x1})
 			_, err := parsePingFrame(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(b.Len()).To(BeZero())
@@ -28,7 +28,7 @@ var _ = Describe("PingFrame", func() {
 			b := &bytes.Buffer{}
 			frame := PingFrame{}
 			frame.Write(b, protocol.VersionWhatever)
-			Expect(b.Bytes()).To(Equal([]byte{0x07}))
+			Expect(b.Bytes()).To(Equal([]byte{0x1}))
 		})
 
 		It("has the correct min length", func() {
diff --git a/internal/wire/reset_stream_frame.go b/internal/wire/reset_stream_frame.go
index 7b4373feb..d3a40dcf9 100644
--- a/internal/wire/reset_stream_frame.go
+++ b/internal/wire/reset_stream_frame.go
@@ -45,7 +45,7 @@ func parseResetStreamFrame(r *bytes.Reader, version protocol.VersionNumber) (*Re
 }
 
 func (f *ResetStreamFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error {
-	b.WriteByte(0x01)
+	b.WriteByte(0x4)
 	utils.WriteVarInt(b, uint64(f.StreamID))
 	utils.BigEndian.WriteUint16(b, uint16(f.ErrorCode))
 	utils.WriteVarInt(b, uint64(f.ByteOffset))
diff --git a/internal/wire/reset_stream_frame_test.go b/internal/wire/reset_stream_frame_test.go
index a09ecc29d..9d28d99cb 100644
--- a/internal/wire/reset_stream_frame_test.go
+++ b/internal/wire/reset_stream_frame_test.go
@@ -12,7 +12,7 @@ import (
 var _ = Describe("RESET_STREAM frame", func() {
 	Context("when parsing", func() {
 		It("accepts sample frame", func() {
-			data := []byte{0x1}
+			data := []byte{0x4}
 			data = append(data, encodeVarInt(0xdeadbeef)...)  // stream ID
 			data = append(data, []byte{0x13, 0x37}...)        // error code
 			data = append(data, encodeVarInt(0x987654321)...) // byte offset
@@ -25,7 +25,7 @@ var _ = Describe("RESET_STREAM frame", func() {
 		})
 
 		It("errors on EOFs", func() {
-			data := []byte{0x1}
+			data := []byte{0x4}
 			data = append(data, encodeVarInt(0xdeadbeef)...)  // stream ID
 			data = append(data, []byte{0x13, 0x37}...)        // error code
 			data = append(data, encodeVarInt(0x987654321)...) // byte offset
@@ -48,7 +48,7 @@ var _ = Describe("RESET_STREAM frame", func() {
 			b := &bytes.Buffer{}
 			err := frame.Write(b, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x1}
+			expected := []byte{0x4}
 			expected = append(expected, encodeVarInt(0x1337)...)
 			expected = append(expected, []byte{0xca, 0xfe}...)
 			expected = append(expected, encodeVarInt(0x11223344decafbad)...)
diff --git a/internal/wire/stop_sending_frame.go b/internal/wire/stop_sending_frame.go
index b5e698047..f9a5d60b0 100644
--- a/internal/wire/stop_sending_frame.go
+++ b/internal/wire/stop_sending_frame.go
@@ -15,7 +15,7 @@ type StopSendingFrame struct {
 
 // parseStopSendingFrame parses a STOP_SENDING frame
 func parseStopSendingFrame(r *bytes.Reader, _ protocol.VersionNumber) (*StopSendingFrame, error) {
-	if _, err := r.ReadByte(); err != nil { // read the TypeByte
+	if _, err := r.ReadByte(); err != nil {
 		return nil, err
 	}
 
@@ -40,7 +40,7 @@ func (f *StopSendingFrame) Length(_ protocol.VersionNumber) protocol.ByteCount {
 }
 
 func (f *StopSendingFrame) Write(b *bytes.Buffer, _ protocol.VersionNumber) error {
-	b.WriteByte(0x0c)
+	b.WriteByte(0x5)
 	utils.WriteVarInt(b, uint64(f.StreamID))
 	utils.BigEndian.WriteUint16(b, uint16(f.ErrorCode))
 	return nil
diff --git a/internal/wire/stop_sending_frame_test.go b/internal/wire/stop_sending_frame_test.go
index 2f93487ac..746a060be 100644
--- a/internal/wire/stop_sending_frame_test.go
+++ b/internal/wire/stop_sending_frame_test.go
@@ -13,7 +13,7 @@ import (
 var _ = Describe("STOP_SENDING frame", func() {
 	Context("when parsing", func() {
 		It("parses a sample frame", func() {
-			data := []byte{0x0c}
+			data := []byte{0x5}
 			data = append(data, encodeVarInt(0xdecafbad)...) // stream ID
 			data = append(data, []byte{0x13, 0x37}...)       // error code
 			b := bytes.NewReader(data)
@@ -25,7 +25,7 @@ var _ = Describe("STOP_SENDING frame", func() {
 		})
 
 		It("errors on EOFs", func() {
-			data := []byte{0x0c}
+			data := []byte{0x5}
 			data = append(data, encodeVarInt(0xdecafbad)...) // stream ID
 			data = append(data, []byte{0x13, 0x37}...)       // error code
 			_, err := parseStopSendingFrame(bytes.NewReader(data), versionIETFFrames)
@@ -46,7 +46,7 @@ var _ = Describe("STOP_SENDING frame", func() {
 			buf := &bytes.Buffer{}
 			err := frame.Write(buf, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x0c}
+			expected := []byte{0x5}
 			expected = append(expected, encodeVarInt(0xdeadbeefcafe)...)
 			expected = append(expected, []byte{0x0, 0x10}...)
 			Expect(buf.Bytes()).To(Equal(expected))
diff --git a/internal/wire/stream_data_blocked_frame.go b/internal/wire/stream_data_blocked_frame.go
index d2d5c1736..9f2e90be0 100644
--- a/internal/wire/stream_data_blocked_frame.go
+++ b/internal/wire/stream_data_blocked_frame.go
@@ -34,7 +34,7 @@ func parseStreamDataBlockedFrame(r *bytes.Reader, _ protocol.VersionNumber) (*St
 }
 
 func (f *StreamDataBlockedFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) error {
-	b.WriteByte(0x09)
+	b.WriteByte(0x15)
 	utils.WriteVarInt(b, uint64(f.StreamID))
 	utils.WriteVarInt(b, uint64(f.DataLimit))
 	return nil
diff --git a/internal/wire/stream_data_blocked_frame_test.go b/internal/wire/stream_data_blocked_frame_test.go
index e39d75690..c264980d5 100644
--- a/internal/wire/stream_data_blocked_frame_test.go
+++ b/internal/wire/stream_data_blocked_frame_test.go
@@ -13,7 +13,7 @@ import (
 var _ = Describe("STREAM_DATA_BLOCKED frame", func() {
 	Context("parsing", func() {
 		It("accepts sample frame", func() {
-			data := []byte{0x9}
+			data := []byte{0x15}
 			data = append(data, encodeVarInt(0xdeadbeef)...) // stream ID
 			data = append(data, encodeVarInt(0xdecafbad)...) // offset
 			b := bytes.NewReader(data)
@@ -25,7 +25,7 @@ var _ = Describe("STREAM_DATA_BLOCKED frame", func() {
 		})
 
 		It("errors on EOFs", func() {
-			data := []byte{0x9}
+			data := []byte{0x15}
 			data = append(data, encodeVarInt(0xdeadbeef)...)
 			data = append(data, encodeVarInt(0xc0010ff)...)
 			_, err := parseStreamDataBlockedFrame(bytes.NewReader(data), versionIETFFrames)
@@ -54,7 +54,7 @@ var _ = Describe("STREAM_DATA_BLOCKED frame", func() {
 			}
 			err := f.Write(b, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x9}
+			expected := []byte{0x15}
 			expected = append(expected, encodeVarInt(uint64(f.StreamID))...)
 			expected = append(expected, encodeVarInt(uint64(f.DataLimit))...)
 			Expect(b.Bytes()).To(Equal(expected))
diff --git a/internal/wire/stream_frame.go b/internal/wire/stream_frame.go
index 70065842a..810ef06b8 100644
--- a/internal/wire/stream_frame.go
+++ b/internal/wire/stream_frame.go
@@ -19,18 +19,17 @@ type StreamFrame struct {
 	Data           []byte
 }
 
-// parseStreamFrame reads a STREAM frame
 func parseStreamFrame(r *bytes.Reader, version protocol.VersionNumber) (*StreamFrame, error) {
-	frame := &StreamFrame{}
-
 	typeByte, err := r.ReadByte()
 	if err != nil {
 		return nil, err
 	}
 
-	frame.FinBit = typeByte&0x1 > 0
-	frame.DataLenPresent = typeByte&0x2 > 0
 	hasOffset := typeByte&0x4 > 0
+	frame := &StreamFrame{
+		FinBit:         typeByte&0x1 > 0,
+		DataLenPresent: typeByte&0x2 > 0,
+	}
 
 	streamID, err := utils.ReadVarInt(r)
 	if err != nil {
@@ -81,7 +80,7 @@ func (f *StreamFrame) Write(b *bytes.Buffer, version protocol.VersionNumber) err
 		return errors.New("StreamFrame: attempting to write empty frame without FIN")
 	}
 
-	typeByte := byte(0x10)
+	typeByte := byte(0x8)
 	if f.FinBit {
 		typeByte ^= 0x1
 	}
diff --git a/internal/wire/stream_frame_test.go b/internal/wire/stream_frame_test.go
index 211acb3ea..7dc7f3ccd 100644
--- a/internal/wire/stream_frame_test.go
+++ b/internal/wire/stream_frame_test.go
@@ -13,7 +13,7 @@ import (
 var _ = Describe("STREAM frame", func() {
 	Context("when parsing", func() {
 		It("parses a frame with OFF bit", func() {
-			data := []byte{0x10 ^ 0x4}
+			data := []byte{0x8 ^ 0x4}
 			data = append(data, encodeVarInt(0x12345)...)    // stream ID
 			data = append(data, encodeVarInt(0xdecafbad)...) // offset
 			data = append(data, []byte("foobar")...)
@@ -28,7 +28,7 @@ var _ = Describe("STREAM frame", func() {
 		})
 
 		It("respects the LEN when parsing the frame", func() {
-			data := []byte{0x10 ^ 0x2}
+			data := []byte{0x8 ^ 0x2}
 			data = append(data, encodeVarInt(0x12345)...) // stream ID
 			data = append(data, encodeVarInt(4)...)       // data length
 			data = append(data, []byte("foobar")...)
@@ -43,7 +43,7 @@ var _ = Describe("STREAM frame", func() {
 		})
 
 		It("parses a frame with FIN bit", func() {
-			data := []byte{0x10 ^ 0x1}
+			data := []byte{0x8 ^ 0x1}
 			data = append(data, encodeVarInt(9)...) // stream ID
 			data = append(data, []byte("foobar")...)
 			r := bytes.NewReader(data)
@@ -57,7 +57,7 @@ var _ = Describe("STREAM frame", func() {
 		})
 
 		It("allows empty frames", func() {
-			data := []byte{0x10 ^ 0x4}
+			data := []byte{0x8 ^ 0x4}
 			data = append(data, encodeVarInt(0x1337)...)  // stream ID
 			data = append(data, encodeVarInt(0x12345)...) // offset
 			r := bytes.NewReader(data)
@@ -70,7 +70,7 @@ var _ = Describe("STREAM frame", func() {
 		})
 
 		It("rejects frames that overflow the maximum offset", func() {
-			data := []byte{0x10 ^ 0x4}
+			data := []byte{0x8 ^ 0x4}
 			data = append(data, encodeVarInt(0x12345)...)                         // stream ID
 			data = append(data, encodeVarInt(uint64(protocol.MaxByteCount-5))...) // offset
 			data = append(data, []byte("foobar")...)
@@ -80,7 +80,7 @@ var _ = Describe("STREAM frame", func() {
 		})
 
 		It("errors on EOFs", func() {
-			data := []byte{0x10 ^ 0x4 ^ 0x2}
+			data := []byte{0x8 ^ 0x4 ^ 0x2}
 			data = append(data, encodeVarInt(0x12345)...)    // stream ID
 			data = append(data, encodeVarInt(0xdecafbad)...) // offset
 			data = append(data, encodeVarInt(6)...)          // data length
@@ -103,7 +103,7 @@ var _ = Describe("STREAM frame", func() {
 			b := &bytes.Buffer{}
 			err := f.Write(b, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x10}
+			expected := []byte{0x8}
 			expected = append(expected, encodeVarInt(0x1337)...) // stream ID
 			expected = append(expected, []byte("foobar")...)
 			Expect(b.Bytes()).To(Equal(expected))
@@ -118,7 +118,7 @@ var _ = Describe("STREAM frame", func() {
 			b := &bytes.Buffer{}
 			err := f.Write(b, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x10 ^ 0x4}
+			expected := []byte{0x8 ^ 0x4}
 			expected = append(expected, encodeVarInt(0x1337)...)   // stream ID
 			expected = append(expected, encodeVarInt(0x123456)...) // offset
 			expected = append(expected, []byte("foobar")...)
@@ -134,7 +134,7 @@ var _ = Describe("STREAM frame", func() {
 			b := &bytes.Buffer{}
 			err := f.Write(b, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x10 ^ 0x4 ^ 0x1}
+			expected := []byte{0x8 ^ 0x4 ^ 0x1}
 			expected = append(expected, encodeVarInt(0x1337)...)   // stream ID
 			expected = append(expected, encodeVarInt(0x123456)...) // offset
 			Expect(b.Bytes()).To(Equal(expected))
@@ -149,7 +149,7 @@ var _ = Describe("STREAM frame", func() {
 			b := &bytes.Buffer{}
 			err := f.Write(b, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x10 ^ 0x2}
+			expected := []byte{0x8 ^ 0x2}
 			expected = append(expected, encodeVarInt(0x1337)...) // stream ID
 			expected = append(expected, encodeVarInt(6)...)      // data length
 			expected = append(expected, []byte("foobar")...)
@@ -166,7 +166,7 @@ var _ = Describe("STREAM frame", func() {
 			b := &bytes.Buffer{}
 			err := f.Write(b, versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
-			expected := []byte{0x10 ^ 0x4 ^ 0x2}
+			expected := []byte{0x8 ^ 0x4 ^ 0x2}
 			expected = append(expected, encodeVarInt(0x1337)...)   // stream ID
 			expected = append(expected, encodeVarInt(0x123456)...) // offset
 			expected = append(expected, encodeVarInt(6)...)        // data length
diff --git a/internal/wire/streams_blocked_frame.go b/internal/wire/streams_blocked_frame.go
index 6a79d9a8e..b41d68f1b 100644
--- a/internal/wire/streams_blocked_frame.go
+++ b/internal/wire/streams_blocked_frame.go
@@ -21,9 +21,9 @@ func parseStreamsBlockedFrame(r *bytes.Reader, _ protocol.VersionNumber) (*Strea
 
 	f := &StreamsBlockedFrame{}
 	switch typeByte {
-	case 0xa:
+	case 0x16:
 		f.Type = protocol.StreamTypeBidi
-	case 0xb:
+	case 0x17:
 		f.Type = protocol.StreamTypeUni
 	}
 	streamLimit, err := utils.ReadVarInt(r)
@@ -38,9 +38,9 @@ func parseStreamsBlockedFrame(r *bytes.Reader, _ protocol.VersionNumber) (*Strea
 func (f *StreamsBlockedFrame) Write(b *bytes.Buffer, _ protocol.VersionNumber) error {
 	switch f.Type {
 	case protocol.StreamTypeBidi:
-		b.WriteByte(0xa)
+		b.WriteByte(0x16)
 	case protocol.StreamTypeUni:
-		b.WriteByte(0xb)
+		b.WriteByte(0x17)
 	}
 	utils.WriteVarInt(b, f.StreamLimit)
 	return nil
diff --git a/internal/wire/streams_blocked_frame_test.go b/internal/wire/streams_blocked_frame_test.go
index 875ca69ec..9c942fd69 100644
--- a/internal/wire/streams_blocked_frame_test.go
+++ b/internal/wire/streams_blocked_frame_test.go
@@ -13,7 +13,7 @@ import (
 var _ = Describe("STREAMS_BLOCKED frame", func() {
 	Context("parsing", func() {
 		It("accepts a frame for bidirectional streams", func() {
-			expected := []byte{0xa}
+			expected := []byte{0x16}
 			expected = append(expected, encodeVarInt(0x1337)...)
 			b := bytes.NewReader(expected)
 			f, err := parseStreamsBlockedFrame(b, protocol.VersionWhatever)
@@ -24,7 +24,7 @@ var _ = Describe("STREAMS_BLOCKED frame", func() {
 		})
 
 		It("accepts a frame for unidirectional streams", func() {
-			expected := []byte{0xb}
+			expected := []byte{0x17}
 			expected = append(expected, encodeVarInt(0x7331)...)
 			b := bytes.NewReader(expected)
 			f, err := parseStreamsBlockedFrame(b, protocol.VersionWhatever)
@@ -35,7 +35,7 @@ var _ = Describe("STREAMS_BLOCKED frame", func() {
 		})
 
 		It("errors on EOFs", func() {
-			data := []byte{0xa}
+			data := []byte{0x16}
 			data = append(data, encodeVarInt(0x12345678)...)
 			_, err := parseStreamsBlockedFrame(bytes.NewReader(data), versionIETFFrames)
 			Expect(err).ToNot(HaveOccurred())
@@ -54,7 +54,7 @@ var _ = Describe("STREAMS_BLOCKED frame", func() {
 				StreamLimit: 0xdeadbeefcafe,
 			}
 			Expect(f.Write(b, protocol.VersionWhatever)).To(Succeed())
-			expected := []byte{0xa}
+			expected := []byte{0x16}
 			expected = append(expected, encodeVarInt(0xdeadbeefcafe)...)
 			Expect(b.Bytes()).To(Equal(expected))
 		})
@@ -66,7 +66,7 @@ var _ = Describe("STREAMS_BLOCKED frame", func() {
 				StreamLimit: 0xdeadbeefcafe,
 			}
 			Expect(f.Write(b, protocol.VersionWhatever)).To(Succeed())
-			expected := []byte{0xb}
+			expected := []byte{0x17}
 			expected = append(expected, encodeVarInt(0xdeadbeefcafe)...)
 			Expect(b.Bytes()).To(Equal(expected))
 		})