diff --git a/.travis.yml b/.travis.yml
index c0eff516a..dff5349ca 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,7 +7,6 @@ addons:
 language: go
 
 go:
-  - 1.8.x
   - 1.9
 
 # first part of the GOARCH workaround
diff --git a/Changelog.md b/Changelog.md
index bb8559cfb..dbb37a7fd 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -15,5 +15,5 @@
 - Changed the log level environment variable to only accept strings ("DEBUG", "INFO", "ERROR"), see [the wiki](https://github.com/lucas-clemente/quic-go/wiki/Logging) for more details.
 - Rename the `h2quic.QuicRoundTripper` to `h2quic.RoundTripper`
 - Changed `h2quic.Server.Serve()` to accept a `net.PacketConn`
-- Drop support for Go 1.7.
+- Drop support for Go 1.7 and 1.8.
 - Various bugfixes
diff --git a/README.md b/README.md
index 6f3a11e5f..760f470c2 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@ As Google's QUIC versions are expected to converge towards the [IETF QUIC draft]
 
 ## Guides
 
-We currently support Go 1.8+.
+We currently support Go 1.9+.
 
 Installing and updating dependencies:
 
diff --git a/ackhandler/interfaces.go b/ackhandler/interfaces.go
index cb1c1a0e1..c7a9c56dd 100644
--- a/ackhandler/interfaces.go
+++ b/ackhandler/interfaces.go
@@ -3,18 +3,18 @@ package ackhandler
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 // SentPacketHandler handles ACKs received for outgoing packets
 type SentPacketHandler interface {
 	// SentPacket may modify the packet
 	SentPacket(packet *Packet) error
-	ReceivedAck(ackFrame *frames.AckFrame, withPacketNumber protocol.PacketNumber, recvTime time.Time) error
+	ReceivedAck(ackFrame *wire.AckFrame, withPacketNumber protocol.PacketNumber, recvTime time.Time) error
 
 	SendingAllowed() bool
-	GetStopWaitingFrame(force bool) *frames.StopWaitingFrame
+	GetStopWaitingFrame(force bool) *wire.StopWaitingFrame
 	ShouldSendRetransmittablePacket() bool
 	DequeuePacketForRetransmission() (packet *Packet)
 	GetLeastUnacked() protocol.PacketNumber
@@ -29,5 +29,5 @@ type ReceivedPacketHandler interface {
 	SetLowerLimit(protocol.PacketNumber)
 
 	GetAlarmTimeout() time.Time
-	GetAckFrame() *frames.AckFrame
+	GetAckFrame() *wire.AckFrame
 }
diff --git a/ackhandler/packet.go b/ackhandler/packet.go
index e9dbf6ab4..9c4ee30be 100644
--- a/ackhandler/packet.go
+++ b/ackhandler/packet.go
@@ -3,15 +3,15 @@ package ackhandler
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 // A Packet is a packet
 // +gen linkedlist
 type Packet struct {
 	PacketNumber    protocol.PacketNumber
-	Frames          []frames.Frame
+	Frames          []wire.Frame
 	Length          protocol.ByteCount
 	EncryptionLevel protocol.EncryptionLevel
 
@@ -19,13 +19,13 @@ type Packet struct {
 }
 
 // GetFramesForRetransmission gets all the frames for retransmission
-func (p *Packet) GetFramesForRetransmission() []frames.Frame {
-	var fs []frames.Frame
+func (p *Packet) GetFramesForRetransmission() []wire.Frame {
+	var fs []wire.Frame
 	for _, frame := range p.Frames {
 		switch frame.(type) {
-		case *frames.AckFrame:
+		case *wire.AckFrame:
 			continue
-		case *frames.StopWaitingFrame:
+		case *wire.StopWaitingFrame:
 			continue
 		}
 		fs = append(fs, frame)
diff --git a/ackhandler/packet_test.go b/ackhandler/packet_test.go
index 32452a325..4d3ae5605 100644
--- a/ackhandler/packet_test.go
+++ b/ackhandler/packet_test.go
@@ -1,37 +1,37 @@
 package ackhandler
 
 import (
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
 
 var _ = Describe("Packet", func() {
 	Context("getting frames for retransmission", func() {
-		ackFrame := &frames.AckFrame{LargestAcked: 13}
-		stopWaitingFrame := &frames.StopWaitingFrame{LeastUnacked: 7331}
-		windowUpdateFrame := &frames.WindowUpdateFrame{StreamID: 999}
+		ackFrame := &wire.AckFrame{LargestAcked: 13}
+		stopWaitingFrame := &wire.StopWaitingFrame{LeastUnacked: 7331}
+		windowUpdateFrame := &wire.WindowUpdateFrame{StreamID: 999}
 
-		streamFrame := &frames.StreamFrame{
+		streamFrame := &wire.StreamFrame{
 			StreamID: 5,
 			Data:     []byte{0x13, 0x37},
 		}
 
-		rstStreamFrame := &frames.RstStreamFrame{
+		rstStreamFrame := &wire.RstStreamFrame{
 			StreamID:  555,
 			ErrorCode: 1337,
 		}
 
 		It("returns nil if there are no retransmittable frames", func() {
 			packet := &Packet{
-				Frames: []frames.Frame{ackFrame, stopWaitingFrame},
+				Frames: []wire.Frame{ackFrame, stopWaitingFrame},
 			}
 			Expect(packet.GetFramesForRetransmission()).To(BeNil())
 		})
 
 		It("returns all retransmittable frames", func() {
 			packet := &Packet{
-				Frames: []frames.Frame{
+				Frames: []wire.Frame{
 					windowUpdateFrame,
 					ackFrame,
 					stopWaitingFrame,
diff --git a/ackhandler/received_packet_handler.go b/ackhandler/received_packet_handler.go
index 5d8c09016..214835cdd 100644
--- a/ackhandler/received_packet_handler.go
+++ b/ackhandler/received_packet_handler.go
@@ -4,8 +4,8 @@ import (
 	"errors"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 var errInvalidPacketNumber = errors.New("ReceivedPacketHandler: Invalid packet number")
@@ -23,7 +23,7 @@ type receivedPacketHandler struct {
 	retransmittablePacketsReceivedSinceLastAck int
 	ackQueued                                  bool
 	ackAlarm                                   time.Time
-	lastAck                                    *frames.AckFrame
+	lastAck                                    *wire.AckFrame
 
 	version protocol.VersionNumber
 }
@@ -113,13 +113,13 @@ func (h *receivedPacketHandler) maybeQueueAck(packetNumber protocol.PacketNumber
 	}
 }
 
-func (h *receivedPacketHandler) GetAckFrame() *frames.AckFrame {
+func (h *receivedPacketHandler) GetAckFrame() *wire.AckFrame {
 	if !h.ackQueued && (h.ackAlarm.IsZero() || h.ackAlarm.After(time.Now())) {
 		return nil
 	}
 
 	ackRanges := h.packetHistory.GetAckRanges()
-	ack := &frames.AckFrame{
+	ack := &wire.AckFrame{
 		LargestAcked:       h.largestObserved,
 		LowestAcked:        ackRanges[len(ackRanges)-1].FirstPacketNumber,
 		PacketReceivedTime: h.largestObservedReceivedTime,
diff --git a/ackhandler/received_packet_handler_test.go b/ackhandler/received_packet_handler_test.go
index f86063438..7e2a1f1ac 100644
--- a/ackhandler/received_packet_handler_test.go
+++ b/ackhandler/received_packet_handler_test.go
@@ -3,8 +3,8 @@ package ackhandler
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -221,8 +221,8 @@ var _ = Describe("receivedPacketHandler", func() {
 				Expect(ack.LargestAcked).To(Equal(protocol.PacketNumber(4)))
 				Expect(ack.LowestAcked).To(Equal(protocol.PacketNumber(1)))
 				Expect(ack.AckRanges).To(HaveLen(2))
-				Expect(ack.AckRanges[0]).To(Equal(frames.AckRange{FirstPacketNumber: 4, LastPacketNumber: 4}))
-				Expect(ack.AckRanges[1]).To(Equal(frames.AckRange{FirstPacketNumber: 1, LastPacketNumber: 1}))
+				Expect(ack.AckRanges[0]).To(Equal(wire.AckRange{FirstPacketNumber: 4, LastPacketNumber: 4}))
+				Expect(ack.AckRanges[1]).To(Equal(wire.AckRange{FirstPacketNumber: 1, LastPacketNumber: 1}))
 			})
 
 			It("accepts packets below the lower limit", func() {
diff --git a/ackhandler/received_packet_history.go b/ackhandler/received_packet_history.go
index a17cae5ea..d8e0880bf 100644
--- a/ackhandler/received_packet_history.go
+++ b/ackhandler/received_packet_history.go
@@ -1,9 +1,9 @@
 package ackhandler
 
 import (
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
@@ -122,22 +122,22 @@ func (h *receivedPacketHistory) IsDuplicate(p protocol.PacketNumber) bool {
 }
 
 // GetAckRanges gets a slice of all AckRanges that can be used in an AckFrame
-func (h *receivedPacketHistory) GetAckRanges() []frames.AckRange {
+func (h *receivedPacketHistory) GetAckRanges() []wire.AckRange {
 	if h.ranges.Len() == 0 {
 		return nil
 	}
 
-	var ackRanges []frames.AckRange
+	var ackRanges []wire.AckRange
 
 	for el := h.ranges.Back(); el != nil; el = el.Prev() {
-		ackRanges = append(ackRanges, frames.AckRange{FirstPacketNumber: el.Value.Start, LastPacketNumber: el.Value.End})
+		ackRanges = append(ackRanges, wire.AckRange{FirstPacketNumber: el.Value.Start, LastPacketNumber: el.Value.End})
 	}
 
 	return ackRanges
 }
 
-func (h *receivedPacketHistory) GetHighestAckRange() frames.AckRange {
-	ackRange := frames.AckRange{}
+func (h *receivedPacketHistory) GetHighestAckRange() wire.AckRange {
+	ackRange := wire.AckRange{}
 	if h.ranges.Len() > 0 {
 		r := h.ranges.Back().Value
 		ackRange.FirstPacketNumber = r.Start
diff --git a/ackhandler/received_packet_history_test.go b/ackhandler/received_packet_history_test.go
index 043e7f0c8..df3f33a3d 100644
--- a/ackhandler/received_packet_history_test.go
+++ b/ackhandler/received_packet_history_test.go
@@ -1,9 +1,9 @@
 package ackhandler
 
 import (
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -298,7 +298,7 @@ var _ = Describe("receivedPacketHistory", func() {
 			hist.ReceivedPacket(5)
 			ackRanges := hist.GetAckRanges()
 			Expect(ackRanges).To(HaveLen(1))
-			Expect(ackRanges[0]).To(Equal(frames.AckRange{FirstPacketNumber: 4, LastPacketNumber: 5}))
+			Expect(ackRanges[0]).To(Equal(wire.AckRange{FirstPacketNumber: 4, LastPacketNumber: 5}))
 		})
 
 		It("gets multiple ACK ranges", func() {
@@ -311,9 +311,9 @@ var _ = Describe("receivedPacketHistory", func() {
 			hist.ReceivedPacket(2)
 			ackRanges := hist.GetAckRanges()
 			Expect(ackRanges).To(HaveLen(3))
-			Expect(ackRanges[0]).To(Equal(frames.AckRange{FirstPacketNumber: 10, LastPacketNumber: 11}))
-			Expect(ackRanges[1]).To(Equal(frames.AckRange{FirstPacketNumber: 4, LastPacketNumber: 6}))
-			Expect(ackRanges[2]).To(Equal(frames.AckRange{FirstPacketNumber: 1, LastPacketNumber: 2}))
+			Expect(ackRanges[0]).To(Equal(wire.AckRange{FirstPacketNumber: 10, LastPacketNumber: 11}))
+			Expect(ackRanges[1]).To(Equal(wire.AckRange{FirstPacketNumber: 4, LastPacketNumber: 6}))
+			Expect(ackRanges[2]).To(Equal(wire.AckRange{FirstPacketNumber: 1, LastPacketNumber: 2}))
 		})
 	})
 
@@ -325,14 +325,14 @@ var _ = Describe("receivedPacketHistory", func() {
 		It("gets a single ACK range", func() {
 			hist.ReceivedPacket(4)
 			hist.ReceivedPacket(5)
-			Expect(hist.GetHighestAckRange()).To(Equal(frames.AckRange{FirstPacketNumber: 4, LastPacketNumber: 5}))
+			Expect(hist.GetHighestAckRange()).To(Equal(wire.AckRange{FirstPacketNumber: 4, LastPacketNumber: 5}))
 		})
 
 		It("gets the highest of multiple ACK ranges", func() {
 			hist.ReceivedPacket(3)
 			hist.ReceivedPacket(6)
 			hist.ReceivedPacket(7)
-			Expect(hist.GetHighestAckRange()).To(Equal(frames.AckRange{FirstPacketNumber: 6, LastPacketNumber: 7}))
+			Expect(hist.GetHighestAckRange()).To(Equal(wire.AckRange{FirstPacketNumber: 6, LastPacketNumber: 7}))
 		})
 	})
 })
diff --git a/ackhandler/retransmittable.go b/ackhandler/retransmittable.go
index 17437b8c9..e6ce46f87 100644
--- a/ackhandler/retransmittable.go
+++ b/ackhandler/retransmittable.go
@@ -1,12 +1,10 @@
 package ackhandler
 
-import (
-	"github.com/lucas-clemente/quic-go/frames"
-)
+import "github.com/lucas-clemente/quic-go/internal/wire"
 
 // Returns a new slice with all non-retransmittable frames deleted.
-func stripNonRetransmittableFrames(fs []frames.Frame) []frames.Frame {
-	res := make([]frames.Frame, 0, len(fs))
+func stripNonRetransmittableFrames(fs []wire.Frame) []wire.Frame {
+	res := make([]wire.Frame, 0, len(fs))
 	for _, f := range fs {
 		if IsFrameRetransmittable(f) {
 			res = append(res, f)
@@ -16,11 +14,11 @@ func stripNonRetransmittableFrames(fs []frames.Frame) []frames.Frame {
 }
 
 // IsFrameRetransmittable returns true if the frame should be retransmitted.
-func IsFrameRetransmittable(f frames.Frame) bool {
+func IsFrameRetransmittable(f wire.Frame) bool {
 	switch f.(type) {
-	case *frames.StopWaitingFrame:
+	case *wire.StopWaitingFrame:
 		return false
-	case *frames.AckFrame:
+	case *wire.AckFrame:
 		return false
 	default:
 		return true
@@ -28,7 +26,7 @@ func IsFrameRetransmittable(f frames.Frame) bool {
 }
 
 // HasRetransmittableFrames returns true if at least one frame is retransmittable.
-func HasRetransmittableFrames(fs []frames.Frame) bool {
+func HasRetransmittableFrames(fs []wire.Frame) bool {
 	for _, f := range fs {
 		if IsFrameRetransmittable(f) {
 			return true
diff --git a/ackhandler/retransmittable_test.go b/ackhandler/retransmittable_test.go
index 4a5ea858b..aecca065c 100644
--- a/ackhandler/retransmittable_test.go
+++ b/ackhandler/retransmittable_test.go
@@ -3,22 +3,22 @@ package ackhandler
 import (
 	"reflect"
 
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
 
 var _ = Describe("retransmittable frames", func() {
-	for fl, el := range map[frames.Frame]bool{
-		&frames.AckFrame{}:             false,
-		&frames.StopWaitingFrame{}:     false,
-		&frames.BlockedFrame{}:         true,
-		&frames.ConnectionCloseFrame{}: true,
-		&frames.GoawayFrame{}:          true,
-		&frames.PingFrame{}:            true,
-		&frames.RstStreamFrame{}:       true,
-		&frames.StreamFrame{}:          true,
-		&frames.WindowUpdateFrame{}:    true,
+	for fl, el := range map[wire.Frame]bool{
+		&wire.AckFrame{}:             false,
+		&wire.StopWaitingFrame{}:     false,
+		&wire.BlockedFrame{}:         true,
+		&wire.ConnectionCloseFrame{}: true,
+		&wire.GoawayFrame{}:          true,
+		&wire.PingFrame{}:            true,
+		&wire.RstStreamFrame{}:       true,
+		&wire.StreamFrame{}:          true,
+		&wire.WindowUpdateFrame{}:    true,
 	} {
 		f := fl
 		e := el
@@ -29,16 +29,16 @@ var _ = Describe("retransmittable frames", func() {
 		})
 
 		It("stripping non-retransmittable frames works for "+fName, func() {
-			s := []frames.Frame{f}
+			s := []wire.Frame{f}
 			if e {
-				Expect(stripNonRetransmittableFrames(s)).To(Equal([]frames.Frame{f}))
+				Expect(stripNonRetransmittableFrames(s)).To(Equal([]wire.Frame{f}))
 			} else {
 				Expect(stripNonRetransmittableFrames(s)).To(BeEmpty())
 			}
 		})
 
 		It("HasRetransmittableFrames works for "+fName, func() {
-			Expect(HasRetransmittableFrames([]frames.Frame{f})).To(Equal(e))
+			Expect(HasRetransmittableFrames([]wire.Frame{f})).To(Equal(e))
 		})
 	}
 })
diff --git a/ackhandler/sent_packet_handler.go b/ackhandler/sent_packet_handler.go
index 4ffaea2c3..5d4076539 100644
--- a/ackhandler/sent_packet_handler.go
+++ b/ackhandler/sent_packet_handler.go
@@ -6,9 +6,9 @@ import (
 	"time"
 
 	"github.com/lucas-clemente/quic-go/congestion"
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
@@ -139,7 +139,7 @@ func (h *sentPacketHandler) SentPacket(packet *Packet) error {
 	return nil
 }
 
-func (h *sentPacketHandler) ReceivedAck(ackFrame *frames.AckFrame, withPacketNumber protocol.PacketNumber, rcvTime time.Time) error {
+func (h *sentPacketHandler) ReceivedAck(ackFrame *wire.AckFrame, withPacketNumber protocol.PacketNumber, rcvTime time.Time) error {
 	if ackFrame.LargestAcked > h.lastSentPacketNumber {
 		return errAckForUnsentPacket
 	}
@@ -187,7 +187,7 @@ func (h *sentPacketHandler) ReceivedAck(ackFrame *frames.AckFrame, withPacketNum
 	return nil
 }
 
-func (h *sentPacketHandler) determineNewlyAckedPackets(ackFrame *frames.AckFrame) ([]*PacketElement, error) {
+func (h *sentPacketHandler) determineNewlyAckedPackets(ackFrame *wire.AckFrame) ([]*PacketElement, error) {
 	var ackedPackets []*PacketElement
 	ackRangeIndex := 0
 	for el := h.packetHistory.Front(); el != nil; el = el.Next() {
@@ -332,7 +332,7 @@ func (h *sentPacketHandler) GetLeastUnacked() protocol.PacketNumber {
 	return h.largestInOrderAcked() + 1
 }
 
-func (h *sentPacketHandler) GetStopWaitingFrame(force bool) *frames.StopWaitingFrame {
+func (h *sentPacketHandler) GetStopWaitingFrame(force bool) *wire.StopWaitingFrame {
 	return h.stopWaitingManager.GetStopWaitingFrame(force)
 }
 
@@ -391,7 +391,7 @@ func (h *sentPacketHandler) computeRTOTimeout() time.Duration {
 	return utils.MinDuration(rto, maxRTOTimeout)
 }
 
-func (h *sentPacketHandler) skippedPacketsAcked(ackFrame *frames.AckFrame) bool {
+func (h *sentPacketHandler) skippedPacketsAcked(ackFrame *wire.AckFrame) bool {
 	for _, p := range h.skippedPackets {
 		if ackFrame.AcksPacket(p) {
 			return true
diff --git a/ackhandler/sent_packet_handler_test.go b/ackhandler/sent_packet_handler_test.go
index f68369f69..153395843 100644
--- a/ackhandler/sent_packet_handler_test.go
+++ b/ackhandler/sent_packet_handler_test.go
@@ -4,8 +4,8 @@ import (
 	"time"
 
 	"github.com/lucas-clemente/quic-go/congestion"
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -58,23 +58,23 @@ func (m *mockCongestion) OnPacketLost(n protocol.PacketNumber, l protocol.ByteCo
 }
 
 func retransmittablePacket(num protocol.PacketNumber) *Packet {
-	return &Packet{PacketNumber: num, Length: 1, Frames: []frames.Frame{&frames.PingFrame{}}}
+	return &Packet{PacketNumber: num, Length: 1, Frames: []wire.Frame{&wire.PingFrame{}}}
 }
 
 func nonRetransmittablePacket(num protocol.PacketNumber) *Packet {
-	return &Packet{PacketNumber: num, Length: 1, Frames: []frames.Frame{&frames.AckFrame{}}}
+	return &Packet{PacketNumber: num, Length: 1, Frames: []wire.Frame{&wire.AckFrame{}}}
 }
 
 var _ = Describe("SentPacketHandler", func() {
 	var (
 		handler     *sentPacketHandler
-		streamFrame frames.StreamFrame
+		streamFrame wire.StreamFrame
 	)
 
 	BeforeEach(func() {
 		rttStats := &congestion.RTTStats{}
 		handler = NewSentPacketHandler(rttStats).(*sentPacketHandler)
-		streamFrame = frames.StreamFrame{
+		streamFrame = wire.StreamFrame{
 			StreamID: 5,
 			Data:     []byte{0x13, 0x37},
 		}
@@ -96,8 +96,8 @@ var _ = Describe("SentPacketHandler", func() {
 
 	Context("registering sent packets", func() {
 		It("accepts two consecutive packets", func() {
-			packet1 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1}
-			packet2 := Packet{PacketNumber: 2, Frames: []frames.Frame{&streamFrame}, Length: 2}
+			packet1 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1}
+			packet2 := Packet{PacketNumber: 2, Frames: []wire.Frame{&streamFrame}, Length: 2}
 			err := handler.SentPacket(&packet1)
 			Expect(err).ToNot(HaveOccurred())
 			err = handler.SentPacket(&packet2)
@@ -110,8 +110,8 @@ var _ = Describe("SentPacketHandler", func() {
 		})
 
 		It("rejects packets with the same packet number", func() {
-			packet1 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1}
-			packet2 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 2}
+			packet1 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1}
+			packet2 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 2}
 			err := handler.SentPacket(&packet1)
 			Expect(err).ToNot(HaveOccurred())
 			err = handler.SentPacket(&packet2)
@@ -123,8 +123,8 @@ var _ = Describe("SentPacketHandler", func() {
 		})
 
 		It("rejects packets with decreasing packet number", func() {
-			packet1 := Packet{PacketNumber: 2, Frames: []frames.Frame{&streamFrame}, Length: 1}
-			packet2 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 2}
+			packet1 := Packet{PacketNumber: 2, Frames: []wire.Frame{&streamFrame}, Length: 1}
+			packet2 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 2}
 			err := handler.SentPacket(&packet1)
 			Expect(err).ToNot(HaveOccurred())
 			err = handler.SentPacket(&packet2)
@@ -135,7 +135,7 @@ var _ = Describe("SentPacketHandler", func() {
 		})
 
 		It("stores the sent time", func() {
-			packet := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1}
+			packet := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1}
 			err := handler.SentPacket(&packet)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(handler.packetHistory.Front().Value.SendTime.Unix()).To(BeNumerically("~", time.Now().Unix(), 1))
@@ -149,8 +149,8 @@ var _ = Describe("SentPacketHandler", func() {
 
 		Context("skipped packet numbers", func() {
 			It("works with non-consecutive packet numbers", func() {
-				packet1 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1}
-				packet2 := Packet{PacketNumber: 3, Frames: []frames.Frame{&streamFrame}, Length: 2}
+				packet1 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1}
+				packet2 := Packet{PacketNumber: 3, Frames: []wire.Frame{&streamFrame}, Length: 2}
 				err := handler.SentPacket(&packet1)
 				Expect(err).ToNot(HaveOccurred())
 				err = handler.SentPacket(&packet2)
@@ -166,9 +166,9 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("recognizes multiple skipped packets", func() {
-				packet1 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1}
-				packet2 := Packet{PacketNumber: 3, Frames: []frames.Frame{&streamFrame}, Length: 2}
-				packet3 := Packet{PacketNumber: 5, Frames: []frames.Frame{&streamFrame}, Length: 2}
+				packet1 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1}
+				packet2 := Packet{PacketNumber: 3, Frames: []wire.Frame{&streamFrame}, Length: 2}
+				packet3 := Packet{PacketNumber: 5, Frames: []wire.Frame{&streamFrame}, Length: 2}
 				err := handler.SentPacket(&packet1)
 				Expect(err).ToNot(HaveOccurred())
 				err = handler.SentPacket(&packet2)
@@ -180,8 +180,8 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("recognizes multiple consecutive skipped packets", func() {
-				packet1 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1}
-				packet2 := Packet{PacketNumber: 4, Frames: []frames.Frame{&streamFrame}, Length: 2}
+				packet1 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1}
+				packet2 := Packet{PacketNumber: 4, Frames: []wire.Frame{&streamFrame}, Length: 2}
 				err := handler.SentPacket(&packet1)
 				Expect(err).ToNot(HaveOccurred())
 				err = handler.SentPacket(&packet2)
@@ -192,7 +192,7 @@ var _ = Describe("SentPacketHandler", func() {
 
 			It("limits the lengths of the skipped packet slice", func() {
 				for i := 0; i < protocol.MaxTrackedSkippedPackets+5; i++ {
-					packet := Packet{PacketNumber: protocol.PacketNumber(2*i + 1), Frames: []frames.Frame{&streamFrame}, Length: 1}
+					packet := Packet{PacketNumber: protocol.PacketNumber(2*i + 1), Frames: []wire.Frame{&streamFrame}, Length: 1}
 					err := handler.SentPacket(&packet)
 					Expect(err).ToNot(HaveOccurred())
 				}
@@ -269,17 +269,17 @@ var _ = Describe("SentPacketHandler", func() {
 
 		BeforeEach(func() {
 			packets = []*Packet{
-				{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 2, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 3, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 4, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 5, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 6, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 7, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 8, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 9, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 10, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 12, Frames: []frames.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 2, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 3, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 4, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 5, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 6, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 7, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 8, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 9, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 10, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 12, Frames: []wire.Frame{&streamFrame}, Length: 1},
 			}
 			for _, packet := range packets {
 				err := handler.SentPacket(packet)
@@ -293,7 +293,7 @@ var _ = Describe("SentPacketHandler", func() {
 		Context("ACK validation", func() {
 			It("rejects duplicate ACKs", func() {
 				largestAcked := 3
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: protocol.PacketNumber(largestAcked),
 					LowestAcked:  1,
 				}
@@ -306,7 +306,7 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("rejects out of order ACKs", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 3,
 				}
 				err := handler.ReceivedAck(&ack, 1337, time.Now())
@@ -319,7 +319,7 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("rejects ACKs with a too high LargestAcked packet number", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: packets[len(packets)-1].PacketNumber + 1337,
 				}
 				err := handler.ReceivedAck(&ack, 1, time.Now())
@@ -328,7 +328,7 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("ignores repeated ACKs", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 3,
 					LowestAcked:  1,
 				}
@@ -342,7 +342,7 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("rejects ACKs for skipped packets", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 12,
 					LowestAcked:  5,
 				}
@@ -351,10 +351,10 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("accepts an ACK that correctly nacks a skipped packet", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 12,
 					LowestAcked:  5,
-					AckRanges: []frames.AckRange{
+					AckRanges: []wire.AckRange{
 						{FirstPacketNumber: 12, LastPacketNumber: 12},
 						{FirstPacketNumber: 5, LastPacketNumber: 10},
 					},
@@ -367,7 +367,7 @@ var _ = Describe("SentPacketHandler", func() {
 
 		Context("acks and nacks the right packets", func() {
 			It("adjusts the LargestAcked", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 5,
 					LowestAcked:  1,
 				}
@@ -383,7 +383,7 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("ACKs all packets for an ACK frame with no missing packets", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 8,
 					LowestAcked:  2,
 				}
@@ -399,10 +399,10 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("handles an ACK frame with one missing packet range", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 9,
 					LowestAcked:  2,
-					AckRanges: []frames.AckRange{ // packets 4 and 5 were lost
+					AckRanges: []wire.AckRange{ // packets 4 and 5 were lost
 						{FirstPacketNumber: 6, LastPacketNumber: 9},
 						{FirstPacketNumber: 2, LastPacketNumber: 3},
 					},
@@ -421,7 +421,7 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("Does not ack packets below the LowestAcked", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 8,
 					LowestAcked:  3,
 				}
@@ -435,10 +435,10 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("handles an ACK with multiple missing packet ranges", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 9,
 					LowestAcked:  1,
-					AckRanges: []frames.AckRange{ // packets 2, 4 and 5, and 8 were lost
+					AckRanges: []wire.AckRange{ // packets 2, 4 and 5, and 8 were lost
 						{FirstPacketNumber: 9, LastPacketNumber: 9},
 						{FirstPacketNumber: 6, LastPacketNumber: 7},
 						{FirstPacketNumber: 3, LastPacketNumber: 3},
@@ -461,10 +461,10 @@ var _ = Describe("SentPacketHandler", func() {
 
 			It("processes an ACK frame that would be sent after a late arrival of a packet", func() {
 				largestObserved := 6
-				ack1 := frames.AckFrame{
+				ack1 := wire.AckFrame{
 					LargestAcked: protocol.PacketNumber(largestObserved),
 					LowestAcked:  1,
-					AckRanges: []frames.AckRange{
+					AckRanges: []wire.AckRange{
 						{FirstPacketNumber: 4, LastPacketNumber: protocol.PacketNumber(largestObserved)},
 						{FirstPacketNumber: 1, LastPacketNumber: 2},
 					},
@@ -474,7 +474,7 @@ var _ = Describe("SentPacketHandler", func() {
 				Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(len(packets) - 5)))
 				el := handler.packetHistory.Front()
 				Expect(el.Value.PacketNumber).To(Equal(protocol.PacketNumber(3)))
-				ack2 := frames.AckFrame{
+				ack2 := wire.AckFrame{
 					LargestAcked: protocol.PacketNumber(largestObserved),
 					LowestAcked:  1,
 				}
@@ -485,10 +485,10 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("processes an ACK frame that would be sent after a late arrival of a packet and another packet", func() {
-				ack1 := frames.AckFrame{
+				ack1 := wire.AckFrame{
 					LargestAcked: 6,
 					LowestAcked:  1,
-					AckRanges: []frames.AckRange{
+					AckRanges: []wire.AckRange{
 						{FirstPacketNumber: 4, LastPacketNumber: 6},
 						{FirstPacketNumber: 1, LastPacketNumber: 2},
 					},
@@ -498,7 +498,7 @@ var _ = Describe("SentPacketHandler", func() {
 				Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(len(packets) - 5)))
 				el := handler.packetHistory.Front()
 				Expect(el.Value.PacketNumber).To(Equal(protocol.PacketNumber(3)))
-				ack2 := frames.AckFrame{
+				ack2 := wire.AckFrame{
 					LargestAcked: 7,
 					LowestAcked:  1,
 				}
@@ -509,7 +509,7 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("processes an ACK that contains old ACK ranges", func() {
-				ack1 := frames.AckFrame{
+				ack1 := wire.AckFrame{
 					LargestAcked: 6,
 					LowestAcked:  1,
 				}
@@ -517,10 +517,10 @@ var _ = Describe("SentPacketHandler", func() {
 				Expect(err).ToNot(HaveOccurred())
 				Expect(handler.packetHistory.Front().Value.PacketNumber).To(Equal(protocol.PacketNumber(7)))
 				Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(len(packets) - 6)))
-				ack2 := frames.AckFrame{
+				ack2 := wire.AckFrame{
 					LargestAcked: 10,
 					LowestAcked:  1,
-					AckRanges: []frames.AckRange{
+					AckRanges: []wire.AckRange{
 						{FirstPacketNumber: 8, LastPacketNumber: 10},
 						{FirstPacketNumber: 3, LastPacketNumber: 3},
 						{FirstPacketNumber: 1, LastPacketNumber: 1},
@@ -542,13 +542,13 @@ var _ = Describe("SentPacketHandler", func() {
 				getPacketElement(2).Value.SendTime = now.Add(-5 * time.Minute)
 				getPacketElement(6).Value.SendTime = now.Add(-1 * time.Minute)
 				// Now, check that the proper times are used when calculating the deltas
-				err := handler.ReceivedAck(&frames.AckFrame{LargestAcked: 1}, 1, time.Now())
+				err := handler.ReceivedAck(&wire.AckFrame{LargestAcked: 1}, 1, time.Now())
 				Expect(err).NotTo(HaveOccurred())
 				Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 10*time.Minute, 1*time.Second))
-				err = handler.ReceivedAck(&frames.AckFrame{LargestAcked: 2}, 2, time.Now())
+				err = handler.ReceivedAck(&wire.AckFrame{LargestAcked: 2}, 2, time.Now())
 				Expect(err).NotTo(HaveOccurred())
 				Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 5*time.Minute, 1*time.Second))
-				err = handler.ReceivedAck(&frames.AckFrame{LargestAcked: 6}, 3, time.Now())
+				err = handler.ReceivedAck(&wire.AckFrame{LargestAcked: 6}, 3, time.Now())
 				Expect(err).NotTo(HaveOccurred())
 				Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 1*time.Minute, 1*time.Second))
 			})
@@ -556,7 +556,7 @@ var _ = Describe("SentPacketHandler", func() {
 			It("uses the DelayTime in the ack frame", func() {
 				now := time.Now()
 				getPacketElement(1).Value.SendTime = now.Add(-10 * time.Minute)
-				err := handler.ReceivedAck(&frames.AckFrame{LargestAcked: 1, DelayTime: 5 * time.Minute}, 1, time.Now())
+				err := handler.ReceivedAck(&wire.AckFrame{LargestAcked: 1, DelayTime: 5 * time.Minute}, 1, time.Now())
 				Expect(err).NotTo(HaveOccurred())
 				Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 5*time.Minute, 1*time.Second))
 			})
@@ -568,13 +568,13 @@ var _ = Describe("SentPacketHandler", func() {
 
 		BeforeEach(func() {
 			packets = []*Packet{
-				{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 2, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 3, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 4, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 5, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 6, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 7, Frames: []frames.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 2, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 3, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 4, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 5, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 6, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 7, Frames: []wire.Frame{&streamFrame}, Length: 1},
 			}
 			for _, packet := range packets {
 				handler.SentPacket(packet)
@@ -582,7 +582,7 @@ var _ = Describe("SentPacketHandler", func() {
 			// Increase RTT, because the tests would be flaky otherwise
 			handler.rttStats.UpdateRTT(time.Minute, 0, time.Now())
 			// Ack a single packet so that we have non-RTO timings
-			handler.ReceivedAck(&frames.AckFrame{LargestAcked: 2, LowestAcked: 2}, 1, time.Now())
+			handler.ReceivedAck(&wire.AckFrame{LargestAcked: 2, LowestAcked: 2}, 1, time.Now())
 			Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(6)))
 		})
 
@@ -604,23 +604,23 @@ var _ = Describe("SentPacketHandler", func() {
 
 		Context("StopWaitings", func() {
 			It("gets a StopWaitingFrame", func() {
-				ack := frames.AckFrame{LargestAcked: 5, LowestAcked: 5}
+				ack := wire.AckFrame{LargestAcked: 5, LowestAcked: 5}
 				err := handler.ReceivedAck(&ack, 2, time.Now())
 				Expect(err).ToNot(HaveOccurred())
-				Expect(handler.GetStopWaitingFrame(false)).To(Equal(&frames.StopWaitingFrame{LeastUnacked: 6}))
+				Expect(handler.GetStopWaitingFrame(false)).To(Equal(&wire.StopWaitingFrame{LeastUnacked: 6}))
 			})
 
 			It("gets a StopWaitingFrame after queueing a retransmission", func() {
 				handler.queuePacketForRetransmission(getPacketElement(5))
-				Expect(handler.GetStopWaitingFrame(false)).To(Equal(&frames.StopWaitingFrame{LeastUnacked: 6}))
+				Expect(handler.GetStopWaitingFrame(false)).To(Equal(&wire.StopWaitingFrame{LeastUnacked: 6}))
 			})
 		})
 	})
 
 	It("calculates bytes in flight", func() {
-		packet1 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1}
-		packet2 := Packet{PacketNumber: 2, Frames: []frames.Frame{&streamFrame}, Length: 2}
-		packet3 := Packet{PacketNumber: 3, Frames: []frames.Frame{&streamFrame}, Length: 3}
+		packet1 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1}
+		packet2 := Packet{PacketNumber: 2, Frames: []wire.Frame{&streamFrame}, Length: 2}
+		packet3 := Packet{PacketNumber: 3, Frames: []wire.Frame{&streamFrame}, Length: 3}
 		err := handler.SentPacket(&packet1)
 		Expect(err).NotTo(HaveOccurred())
 		Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(1)))
@@ -635,10 +635,10 @@ var _ = Describe("SentPacketHandler", func() {
 		handler.rttStats.UpdateRTT(time.Minute, 0, time.Now())
 
 		// ACK 1 and 3, NACK 2
-		ack := frames.AckFrame{
+		ack := wire.AckFrame{
 			LargestAcked: 3,
 			LowestAcked:  1,
-			AckRanges: []frames.AckRange{
+			AckRanges: []wire.AckRange{
 				{FirstPacketNumber: 3, LastPacketNumber: 3},
 				{FirstPacketNumber: 1, LastPacketNumber: 1},
 			},
@@ -667,7 +667,7 @@ var _ = Describe("SentPacketHandler", func() {
 			p := &Packet{
 				PacketNumber: 1,
 				Length:       42,
-				Frames:       []frames.Frame{&frames.PingFrame{}},
+				Frames:       []wire.Frame{&wire.PingFrame{}},
 			}
 			err := handler.SentPacket(p)
 			Expect(err).NotTo(HaveOccurred())
@@ -680,7 +680,7 @@ var _ = Describe("SentPacketHandler", func() {
 		It("should call MaybeExitSlowStart and OnPacketAcked", func() {
 			handler.SentPacket(retransmittablePacket(1))
 			handler.SentPacket(retransmittablePacket(2))
-			err := handler.ReceivedAck(&frames.AckFrame{LargestAcked: 1, LowestAcked: 1}, 1, time.Now())
+			err := handler.ReceivedAck(&wire.AckFrame{LargestAcked: 1, LowestAcked: 1}, 1, time.Now())
 			Expect(err).NotTo(HaveOccurred())
 			Expect(cong.maybeExitSlowStart).To(BeTrue())
 			Expect(cong.packetsAcked).To(BeEquivalentTo([][]interface{}{
@@ -707,7 +707,7 @@ var _ = Describe("SentPacketHandler", func() {
 			Expect(handler.SendingAllowed()).To(BeTrue())
 			err := handler.SentPacket(&Packet{
 				PacketNumber: 1,
-				Frames:       []frames.Frame{&frames.PingFrame{}},
+				Frames:       []wire.Frame{&wire.PingFrame{}},
 				Length:       protocol.DefaultTCPMSS + 1,
 			})
 			Expect(err).NotTo(HaveOccurred())
@@ -723,7 +723,7 @@ var _ = Describe("SentPacketHandler", func() {
 		It("allows sending if there are retransmisisons outstanding", func() {
 			err := handler.SentPacket(&Packet{
 				PacketNumber: 1,
-				Frames:       []frames.Frame{&frames.PingFrame{}},
+				Frames:       []wire.Frame{&wire.PingFrame{}},
 				Length:       protocol.DefaultTCPMSS + 1,
 			})
 			Expect(err).NotTo(HaveOccurred())
@@ -775,7 +775,7 @@ var _ = Describe("SentPacketHandler", func() {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(handler.lossTime.IsZero()).To(BeTrue())
 
-			err = handler.ReceivedAck(&frames.AckFrame{LargestAcked: 2, LowestAcked: 2}, 1, time.Now().Add(time.Hour))
+			err = handler.ReceivedAck(&wire.AckFrame{LargestAcked: 2, LowestAcked: 2}, 1, time.Now().Add(time.Hour))
 			Expect(err).NotTo(HaveOccurred())
 			Expect(handler.lossTime.IsZero()).To(BeFalse())
 
@@ -798,7 +798,7 @@ var _ = Describe("SentPacketHandler", func() {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(handler.lossTime.IsZero()).To(BeTrue())
 
-			err = handler.ReceivedAck(&frames.AckFrame{LargestAcked: 1, LowestAcked: 1}, 1, time.Now().Add(time.Hour))
+			err = handler.ReceivedAck(&wire.AckFrame{LargestAcked: 1, LowestAcked: 1}, 1, time.Now().Add(time.Hour))
 			Expect(err).NotTo(HaveOccurred())
 			Expect(handler.lossTime.IsZero()).To(BeTrue())
 			Expect(handler.GetAlarmTimeout().Sub(time.Now())).To(BeNumerically("~", handler.computeRTOTimeout(), time.Minute))
diff --git a/ackhandler/stop_waiting_manager.go b/ackhandler/stop_waiting_manager.go
index dfd79ae0f..04cb61f9d 100644
--- a/ackhandler/stop_waiting_manager.go
+++ b/ackhandler/stop_waiting_manager.go
@@ -1,8 +1,8 @@
 package ackhandler
 
 import (
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 // This stopWaitingManager is not supposed to satisfy the StopWaitingManager interface, which is a remnant of the legacy AckHandler, and should be remove once we drop support for QUIC 33
@@ -10,10 +10,10 @@ type stopWaitingManager struct {
 	largestLeastUnackedSent protocol.PacketNumber
 	nextLeastUnacked        protocol.PacketNumber
 
-	lastStopWaitingFrame *frames.StopWaitingFrame
+	lastStopWaitingFrame *wire.StopWaitingFrame
 }
 
-func (s *stopWaitingManager) GetStopWaitingFrame(force bool) *frames.StopWaitingFrame {
+func (s *stopWaitingManager) GetStopWaitingFrame(force bool) *wire.StopWaitingFrame {
 	if s.nextLeastUnacked <= s.largestLeastUnackedSent {
 		if force {
 			return s.lastStopWaitingFrame
@@ -22,14 +22,14 @@ func (s *stopWaitingManager) GetStopWaitingFrame(force bool) *frames.StopWaiting
 	}
 
 	s.largestLeastUnackedSent = s.nextLeastUnacked
-	swf := &frames.StopWaitingFrame{
+	swf := &wire.StopWaitingFrame{
 		LeastUnacked: s.nextLeastUnacked,
 	}
 	s.lastStopWaitingFrame = swf
 	return swf
 }
 
-func (s *stopWaitingManager) ReceivedAck(ack *frames.AckFrame) {
+func (s *stopWaitingManager) ReceivedAck(ack *wire.AckFrame) {
 	if ack.LargestAcked >= s.nextLeastUnacked {
 		s.nextLeastUnacked = ack.LargestAcked + 1
 	}
diff --git a/ackhandler/stop_waiting_manager_test.go b/ackhandler/stop_waiting_manager_test.go
index 73fdf1d85..809c55dbe 100644
--- a/ackhandler/stop_waiting_manager_test.go
+++ b/ackhandler/stop_waiting_manager_test.go
@@ -1,7 +1,7 @@
 package ackhandler
 
 import (
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -18,38 +18,38 @@ var _ = Describe("StopWaitingManager", func() {
 	})
 
 	It("returns a StopWaitingFrame, when a new ACK arrives", func() {
-		manager.ReceivedAck(&frames.AckFrame{LargestAcked: 10})
-		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&frames.StopWaitingFrame{LeastUnacked: 11}))
+		manager.ReceivedAck(&wire.AckFrame{LargestAcked: 10})
+		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&wire.StopWaitingFrame{LeastUnacked: 11}))
 	})
 
 	It("does not decrease the LeastUnacked", func() {
-		manager.ReceivedAck(&frames.AckFrame{LargestAcked: 10})
-		manager.ReceivedAck(&frames.AckFrame{LargestAcked: 9})
-		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&frames.StopWaitingFrame{LeastUnacked: 11}))
+		manager.ReceivedAck(&wire.AckFrame{LargestAcked: 10})
+		manager.ReceivedAck(&wire.AckFrame{LargestAcked: 9})
+		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&wire.StopWaitingFrame{LeastUnacked: 11}))
 	})
 
 	It("does not send the same StopWaitingFrame twice", func() {
-		manager.ReceivedAck(&frames.AckFrame{LargestAcked: 10})
+		manager.ReceivedAck(&wire.AckFrame{LargestAcked: 10})
 		Expect(manager.GetStopWaitingFrame(false)).ToNot(BeNil())
 		Expect(manager.GetStopWaitingFrame(false)).To(BeNil())
 	})
 
 	It("gets the same StopWaitingFrame twice, if forced", func() {
-		manager.ReceivedAck(&frames.AckFrame{LargestAcked: 10})
+		manager.ReceivedAck(&wire.AckFrame{LargestAcked: 10})
 		Expect(manager.GetStopWaitingFrame(false)).ToNot(BeNil())
 		Expect(manager.GetStopWaitingFrame(true)).ToNot(BeNil())
 		Expect(manager.GetStopWaitingFrame(true)).ToNot(BeNil())
 	})
 
 	It("increases the LeastUnacked when a retransmission is queued", func() {
-		manager.ReceivedAck(&frames.AckFrame{LargestAcked: 10})
+		manager.ReceivedAck(&wire.AckFrame{LargestAcked: 10})
 		manager.QueuedRetransmissionForPacketNumber(20)
-		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&frames.StopWaitingFrame{LeastUnacked: 21}))
+		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&wire.StopWaitingFrame{LeastUnacked: 21}))
 	})
 
 	It("does not decrease the LeastUnacked when a retransmission is queued", func() {
-		manager.ReceivedAck(&frames.AckFrame{LargestAcked: 10})
+		manager.ReceivedAck(&wire.AckFrame{LargestAcked: 10})
 		manager.QueuedRetransmissionForPacketNumber(9)
-		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&frames.StopWaitingFrame{LeastUnacked: 11}))
+		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&wire.StopWaitingFrame{LeastUnacked: 11}))
 	})
 })
diff --git a/benchmark/benchmark_test.go b/benchmark/benchmark_test.go
index de2de42f2..0d4f15f05 100644
--- a/benchmark/benchmark_test.go
+++ b/benchmark/benchmark_test.go
@@ -9,8 +9,8 @@ import (
 	"net"
 
 	quic "github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/testdata"
-	"github.com/lucas-clemente/quic-go/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/buffer_pool.go b/buffer_pool.go
index f592d475a..5032ca7f1 100644
--- a/buffer_pool.go
+++ b/buffer_pool.go
@@ -3,7 +3,7 @@ package quic
 import (
 	"sync"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 var bufferPool sync.Pool
diff --git a/buffer_pool_test.go b/buffer_pool_test.go
index 888dc5768..49e37a68e 100644
--- a/buffer_pool_test.go
+++ b/buffer_pool_test.go
@@ -1,7 +1,7 @@
 package quic
 
 import (
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
diff --git a/client.go b/client.go
index 081f1259e..9b7b7ff0f 100644
--- a/client.go
+++ b/client.go
@@ -10,8 +10,9 @@ import (
 	"sync"
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
@@ -224,7 +225,7 @@ func (c *client) handlePacket(remoteAddr net.Addr, packet []byte) {
 	rcvTime := time.Now()
 
 	r := bytes.NewReader(packet)
-	hdr, err := ParsePublicHeader(r, protocol.PerspectiveServer, c.version)
+	hdr, err := wire.ParsePublicHeader(r, protocol.PerspectiveServer, c.version)
 	if err != nil {
 		utils.Errorf("error parsing packet from %s: %s", remoteAddr.String(), err.Error())
 		// drop this packet if we can't parse the Public Header
@@ -243,13 +244,13 @@ func (c *client) handlePacket(remoteAddr net.Addr, packet []byte) {
 			utils.Infof("Received a spoofed Public Reset. Ignoring.")
 			return
 		}
-		pr, err := parsePublicReset(r)
+		pr, err := wire.ParsePublicReset(r)
 		if err != nil {
 			utils.Infof("Received a Public Reset for connection %x. An error occurred parsing the packet.")
 			return
 		}
-		utils.Infof("Received Public Reset, rejected packet number: %#x.", pr.rejectedPacketNumber)
-		c.session.closeRemote(qerr.Error(qerr.PublicReset, fmt.Sprintf("Received a Public Reset for packet number %#x", pr.rejectedPacketNumber)))
+		utils.Infof("Received Public Reset, rejected packet number: %#x.", pr.RejectedPacketNumber)
+		c.session.closeRemote(qerr.Error(qerr.PublicReset, fmt.Sprintf("Received a Public Reset for packet number %#x", pr.RejectedPacketNumber)))
 		return
 	}
 
@@ -280,7 +281,7 @@ func (c *client) handlePacket(remoteAddr net.Addr, packet []byte) {
 	})
 }
 
-func (c *client) handlePacketWithVersionFlag(hdr *PublicHeader) error {
+func (c *client) handlePacketWithVersionFlag(hdr *wire.PublicHeader) error {
 	for _, v := range hdr.SupportedVersions {
 		if v == c.version {
 			// the version negotiation packet contains the version that we offered
diff --git a/client_test.go b/client_test.go
index fc0271fb9..05ec1fdc9 100644
--- a/client_test.go
+++ b/client_test.go
@@ -7,7 +7,8 @@ import (
 	"net"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	"github.com/lucas-clemente/quic-go/qerr"
 
 	. "github.com/onsi/ginkgo"
@@ -228,7 +229,7 @@ var _ = Describe("Client", func() {
 
 		Context("version negotiation", func() {
 			It("recognizes that a packet without VersionFlag means that the server accepted the suggested version", func() {
-				ph := PublicHeader{
+				ph := wire.PublicHeader{
 					PacketNumber:    1,
 					PacketNumberLen: protocol.PacketNumberLen2,
 					ConnectionID:    0x1337,
@@ -262,7 +263,7 @@ var _ = Describe("Client", func() {
 				Expect(newVersion).ToNot(Equal(cl.version))
 				Expect(sess.packetCount).To(BeZero())
 				cl.connectionID = 0x1337
-				cl.handlePacket(nil, composeVersionNegotiation(0x1337, []protocol.VersionNumber{newVersion}))
+				cl.handlePacket(nil, wire.ComposeVersionNegotiation(0x1337, []protocol.VersionNumber{newVersion}))
 				Expect(cl.version).To(Equal(newVersion))
 				Expect(cl.versionNegotiated).To(BeTrue())
 				// it swapped the sessions
@@ -274,7 +275,7 @@ var _ = Describe("Client", func() {
 			})
 
 			It("errors if no matching version is found", func() {
-				cl.handlePacket(nil, composeVersionNegotiation(0x1337, []protocol.VersionNumber{1}))
+				cl.handlePacket(nil, wire.ComposeVersionNegotiation(0x1337, []protocol.VersionNumber{1}))
 				Expect(cl.session.(*mockSession).closed).To(BeTrue())
 				Expect(cl.session.(*mockSession).closeReason).To(MatchError(qerr.InvalidVersion))
 			})
@@ -283,13 +284,13 @@ var _ = Describe("Client", func() {
 				v := protocol.SupportedVersions[1]
 				Expect(v).ToNot(Equal(cl.version))
 				Expect(config.Versions).ToNot(ContainElement(v))
-				cl.handlePacket(nil, composeVersionNegotiation(0x1337, []protocol.VersionNumber{v}))
+				cl.handlePacket(nil, wire.ComposeVersionNegotiation(0x1337, []protocol.VersionNumber{v}))
 				Expect(cl.session.(*mockSession).closed).To(BeTrue())
 				Expect(cl.session.(*mockSession).closeReason).To(MatchError(qerr.InvalidVersion))
 			})
 
 			It("changes to the version preferred by the quic.Config", func() {
-				cl.handlePacket(nil, composeVersionNegotiation(0x1337, []protocol.VersionNumber{config.Versions[2], config.Versions[1]}))
+				cl.handlePacket(nil, wire.ComposeVersionNegotiation(0x1337, []protocol.VersionNumber{config.Versions[2], config.Versions[1]}))
 				Expect(cl.version).To(Equal(config.Versions[1]))
 			})
 
@@ -297,14 +298,14 @@ var _ = Describe("Client", func() {
 				// if the version was not yet negotiated, handlePacket would return a VersionNegotiationMismatch error, see above test
 				cl.versionNegotiated = true
 				Expect(sess.packetCount).To(BeZero())
-				cl.handlePacket(nil, composeVersionNegotiation(0x1337, []protocol.VersionNumber{1}))
+				cl.handlePacket(nil, wire.ComposeVersionNegotiation(0x1337, []protocol.VersionNumber{1}))
 				Expect(cl.versionNegotiated).To(BeTrue())
 				Expect(sess.packetCount).To(BeZero())
 			})
 
 			It("drops version negotiation packets that contain the offered version", func() {
 				ver := cl.version
-				cl.handlePacket(nil, composeVersionNegotiation(0x1337, []protocol.VersionNumber{ver}))
+				cl.handlePacket(nil, wire.ComposeVersionNegotiation(0x1337, []protocol.VersionNumber{ver}))
 				Expect(cl.version).To(Equal(ver))
 			})
 		})
@@ -351,7 +352,7 @@ var _ = Describe("Client", func() {
 
 	Context("handling packets", func() {
 		It("handles packets", func() {
-			ph := PublicHeader{
+			ph := wire.PublicHeader{
 				PacketNumber:    1,
 				PacketNumberLen: protocol.PacketNumberLen2,
 				ConnectionID:    0x1337,
@@ -385,27 +386,27 @@ var _ = Describe("Client", func() {
 
 	Context("Public Reset handling", func() {
 		It("closes the session when receiving a Public Reset", func() {
-			cl.handlePacket(addr, writePublicReset(cl.connectionID, 1, 0))
+			cl.handlePacket(addr, wire.WritePublicReset(cl.connectionID, 1, 0))
 			Expect(cl.session.(*mockSession).closed).To(BeTrue())
 			Expect(cl.session.(*mockSession).closedRemote).To(BeTrue())
 			Expect(cl.session.(*mockSession).closeReason.(*qerr.QuicError).ErrorCode).To(Equal(qerr.PublicReset))
 		})
 
 		It("ignores Public Resets with the wrong connection ID", func() {
-			cl.handlePacket(addr, writePublicReset(cl.connectionID+1, 1, 0))
+			cl.handlePacket(addr, wire.WritePublicReset(cl.connectionID+1, 1, 0))
 			Expect(cl.session.(*mockSession).closed).To(BeFalse())
 			Expect(cl.session.(*mockSession).closedRemote).To(BeFalse())
 		})
 
 		It("ignores Public Resets from the wrong remote address", func() {
 			spoofedAddr := &net.UDPAddr{IP: net.IPv4(1, 2, 3, 4), Port: 5678}
-			cl.handlePacket(spoofedAddr, writePublicReset(cl.connectionID, 1, 0))
+			cl.handlePacket(spoofedAddr, wire.WritePublicReset(cl.connectionID, 1, 0))
 			Expect(cl.session.(*mockSession).closed).To(BeFalse())
 			Expect(cl.session.(*mockSession).closedRemote).To(BeFalse())
 		})
 
 		It("ignores unparseable Public Resets", func() {
-			pr := writePublicReset(cl.connectionID, 1, 0)
+			pr := wire.WritePublicReset(cl.connectionID, 1, 0)
 			cl.handlePacket(addr, pr[:len(pr)-5])
 			Expect(cl.session.(*mockSession).closed).To(BeFalse())
 			Expect(cl.session.(*mockSession).closedRemote).To(BeFalse())
diff --git a/congestion/bandwidth.go b/congestion/bandwidth.go
index e76ea161c..54269c567 100644
--- a/congestion/bandwidth.go
+++ b/congestion/bandwidth.go
@@ -3,7 +3,7 @@ package congestion
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // Bandwidth of a connection
diff --git a/congestion/cubic.go b/congestion/cubic.go
index 62e735563..3922f4760 100644
--- a/congestion/cubic.go
+++ b/congestion/cubic.go
@@ -4,8 +4,8 @@ import (
 	"math"
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 // This cubic implementation is based on the one found in Chromiums's QUIC
diff --git a/congestion/cubic_sender.go b/congestion/cubic_sender.go
index 02e4206b6..f2c8c2d60 100644
--- a/congestion/cubic_sender.go
+++ b/congestion/cubic_sender.go
@@ -3,8 +3,8 @@ package congestion
 import (
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 const (
diff --git a/congestion/cubic_sender_test.go b/congestion/cubic_sender_test.go
index 8afd426e0..2353c42f3 100644
--- a/congestion/cubic_sender_test.go
+++ b/congestion/cubic_sender_test.go
@@ -3,7 +3,7 @@ package congestion
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/congestion/cubic_test.go b/congestion/cubic_test.go
index 3f12c8b97..713e919ce 100644
--- a/congestion/cubic_test.go
+++ b/congestion/cubic_test.go
@@ -4,7 +4,7 @@ import (
 	"math"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/congestion/hybrid_slow_start.go b/congestion/hybrid_slow_start.go
index 01a64f826..f41c1e5c3 100644
--- a/congestion/hybrid_slow_start.go
+++ b/congestion/hybrid_slow_start.go
@@ -3,8 +3,8 @@ package congestion
 import (
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 // Note(pwestin): the magic clamping numbers come from the original code in
diff --git a/congestion/hybrid_slow_start_test.go b/congestion/hybrid_slow_start_test.go
index 43379f5c6..967c0dbc1 100644
--- a/congestion/hybrid_slow_start_test.go
+++ b/congestion/hybrid_slow_start_test.go
@@ -3,7 +3,7 @@ package congestion
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/congestion/interface.go b/congestion/interface.go
index bbce0a637..411a5f2f0 100644
--- a/congestion/interface.go
+++ b/congestion/interface.go
@@ -3,7 +3,7 @@ package congestion
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // A SendAlgorithm performs congestion control and calculates the congestion window
diff --git a/congestion/prr_sender.go b/congestion/prr_sender.go
index b8a0a10be..18a3736a8 100644
--- a/congestion/prr_sender.go
+++ b/congestion/prr_sender.go
@@ -3,8 +3,8 @@ package congestion
 import (
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 // PrrSender implements the Proportional Rate Reduction (PRR) per RFC 6937
diff --git a/congestion/prr_sender_test.go b/congestion/prr_sender_test.go
index 207ddf6c1..e6b4f7281 100644
--- a/congestion/prr_sender_test.go
+++ b/congestion/prr_sender_test.go
@@ -4,8 +4,8 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 var _ = Describe("PRR sender", func() {
diff --git a/congestion/stats.go b/congestion/stats.go
index 8f272b26d..ed669c146 100644
--- a/congestion/stats.go
+++ b/congestion/stats.go
@@ -1,6 +1,6 @@
 package congestion
 
-import "github.com/lucas-clemente/quic-go/protocol"
+import "github.com/lucas-clemente/quic-go/internal/protocol"
 
 type connectionStats struct {
 	slowstartPacketsLost protocol.PacketNumber
diff --git a/crypto/AEAD.go b/crypto/AEAD.go
index a59ce6e8e..9c8a73c1c 100644
--- a/crypto/AEAD.go
+++ b/crypto/AEAD.go
@@ -1,6 +1,6 @@
 package crypto
 
-import "github.com/lucas-clemente/quic-go/protocol"
+import "github.com/lucas-clemente/quic-go/internal/protocol"
 
 // An AEAD implements QUIC's authenticated encryption and associated data
 type AEAD interface {
diff --git a/crypto/aesgcm_aead.go b/crypto/aesgcm_aead.go
index a738cc2b1..baaed5c82 100644
--- a/crypto/aesgcm_aead.go
+++ b/crypto/aesgcm_aead.go
@@ -6,7 +6,7 @@ import (
 
 	"github.com/lucas-clemente/aes12"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 type aeadAESGCM struct {
diff --git a/crypto/cert_cache.go b/crypto/cert_cache.go
index 3ebdc1ae5..d8e8d8f36 100644
--- a/crypto/cert_cache.go
+++ b/crypto/cert_cache.go
@@ -5,7 +5,7 @@ import (
 	"hash/fnv"
 
 	"github.com/hashicorp/golang-lru"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 var (
diff --git a/crypto/chacha20poly1305_aead.go b/crypto/chacha20poly1305_aead.go
index 5c58c4e3c..3e9c1deeb 100644
--- a/crypto/chacha20poly1305_aead.go
+++ b/crypto/chacha20poly1305_aead.go
@@ -8,7 +8,7 @@ import (
 
 	"github.com/aead/chacha20"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 type aeadChacha20Poly1305 struct {
diff --git a/crypto/key_derivation.go b/crypto/key_derivation.go
index 8670da0e7..86b68e304 100644
--- a/crypto/key_derivation.go
+++ b/crypto/key_derivation.go
@@ -5,8 +5,8 @@ import (
 	"crypto/sha256"
 	"io"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 
 	"golang.org/x/crypto/hkdf"
 )
diff --git a/crypto/key_derivation_test.go b/crypto/key_derivation_test.go
index 9c02c9876..f929e73fa 100644
--- a/crypto/key_derivation_test.go
+++ b/crypto/key_derivation_test.go
@@ -1,7 +1,7 @@
 package crypto
 
 import (
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
diff --git a/crypto/nonce.go b/crypto/nonce.go
index 9b6d41645..f862f461d 100644
--- a/crypto/nonce.go
+++ b/crypto/nonce.go
@@ -3,7 +3,7 @@ package crypto
 import (
 	"encoding/binary"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 func makeNonce(iv []byte, packetNumber protocol.PacketNumber) []byte {
diff --git a/crypto/null_aead.go b/crypto/null_aead.go
index ed8566337..d33c90fb5 100644
--- a/crypto/null_aead.go
+++ b/crypto/null_aead.go
@@ -5,7 +5,7 @@ import (
 	"errors"
 
 	"github.com/lucas-clemente/fnv128a"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // nullAEAD handles not-yet encrypted packets
diff --git a/crypto/null_aead_test.go b/crypto/null_aead_test.go
index 144715a67..b327b299f 100644
--- a/crypto/null_aead_test.go
+++ b/crypto/null_aead_test.go
@@ -1,7 +1,7 @@
 package crypto
 
 import (
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/frames/log.go b/frames/log.go
deleted file mode 100644
index 6b7fdcec4..000000000
--- a/frames/log.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package frames
-
-import "github.com/lucas-clemente/quic-go/internal/utils"
-
-// LogFrame logs a frame, either sent or received
-func LogFrame(frame Frame, sent bool) {
-	if !utils.Debug() {
-		return
-	}
-	dir := "<-"
-	if sent {
-		dir = "->"
-	}
-	switch f := frame.(type) {
-	case *StreamFrame:
-		utils.Debugf("\t%s &frames.StreamFrame{StreamID: %d, FinBit: %t, Offset: 0x%x, Data length: 0x%x, Offset + Data length: 0x%x}", dir, f.StreamID, f.FinBit, f.Offset, f.DataLen(), f.Offset+f.DataLen())
-	case *StopWaitingFrame:
-		if sent {
-			utils.Debugf("\t%s &frames.StopWaitingFrame{LeastUnacked: 0x%x, PacketNumberLen: 0x%x}", dir, f.LeastUnacked, f.PacketNumberLen)
-		} else {
-			utils.Debugf("\t%s &frames.StopWaitingFrame{LeastUnacked: 0x%x}", dir, f.LeastUnacked)
-		}
-	case *AckFrame:
-		utils.Debugf("\t%s &frames.AckFrame{LargestAcked: 0x%x, LowestAcked: 0x%x, AckRanges: %#v, DelayTime: %s}", dir, f.LargestAcked, f.LowestAcked, f.AckRanges, f.DelayTime.String())
-	default:
-		utils.Debugf("\t%s %#v", dir, frame)
-	}
-}
diff --git a/h2quic/client.go b/h2quic/client.go
index 866b11abc..bdc70a030 100644
--- a/h2quic/client.go
+++ b/h2quic/client.go
@@ -15,8 +15,8 @@ import (
 	"golang.org/x/net/idna"
 
 	quic "github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
diff --git a/h2quic/client_test.go b/h2quic/client_test.go
index 5be4b2f49..aa61f36b7 100644
--- a/h2quic/client_test.go
+++ b/h2quic/client_test.go
@@ -12,7 +12,7 @@ import (
 	"golang.org/x/net/http2/hpack"
 
 	quic "github.com/lucas-clemente/quic-go"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 
 	"time"
diff --git a/h2quic/request_writer.go b/h2quic/request_writer.go
index dad591cc2..3f323691f 100644
--- a/h2quic/request_writer.go
+++ b/h2quic/request_writer.go
@@ -13,8 +13,8 @@ import (
 	"golang.org/x/net/lex/httplex"
 
 	quic "github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 type requestWriter struct {
diff --git a/h2quic/response_writer.go b/h2quic/response_writer.go
index 246893468..e3eeb3b0e 100644
--- a/h2quic/response_writer.go
+++ b/h2quic/response_writer.go
@@ -8,8 +8,8 @@ import (
 	"sync"
 
 	quic "github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"golang.org/x/net/http2"
 	"golang.org/x/net/http2/hpack"
 )
diff --git a/h2quic/response_writer_test.go b/h2quic/response_writer_test.go
index 735dbd03f..e8de1a4f5 100644
--- a/h2quic/response_writer_test.go
+++ b/h2quic/response_writer_test.go
@@ -11,7 +11,7 @@ import (
 	"golang.org/x/net/http2"
 	"golang.org/x/net/http2/hpack"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/h2quic/server.go b/h2quic/server.go
index 3647dc681..9a68ab59e 100644
--- a/h2quic/server.go
+++ b/h2quic/server.go
@@ -13,8 +13,8 @@ import (
 	"time"
 
 	quic "github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 	"golang.org/x/net/http2"
 	"golang.org/x/net/http2/hpack"
diff --git a/h2quic/server_test.go b/h2quic/server_test.go
index 171b50c2e..b576dbbad 100644
--- a/h2quic/server_test.go
+++ b/h2quic/server_test.go
@@ -18,8 +18,8 @@ import (
 	"golang.org/x/net/http2/hpack"
 
 	quic "github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/testdata"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 
 	. "github.com/onsi/ginkgo"
diff --git a/handshake/connection_parameters_manager.go b/handshake/connection_parameters_manager.go
index 81dadc74e..a69f10bc7 100644
--- a/handshake/connection_parameters_manager.go
+++ b/handshake/connection_parameters_manager.go
@@ -5,8 +5,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
diff --git a/handshake/connection_parameters_manager_test.go b/handshake/connection_parameters_manager_test.go
index d290262e6..b1ff4d1d6 100644
--- a/handshake/connection_parameters_manager_test.go
+++ b/handshake/connection_parameters_manager_test.go
@@ -5,7 +5,7 @@ import (
 	"math"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -148,10 +148,10 @@ var _ = Describe("ConnectionsParameterManager", func() {
 		})
 
 		It("has the correct default flow control windows for receiving", func() {
-			Expect(cpm.GetReceiveStreamFlowControlWindow()).To(Equal(protocol.ReceiveStreamFlowControlWindow))
-			Expect(cpm.GetReceiveConnectionFlowControlWindow()).To(Equal(protocol.ReceiveConnectionFlowControlWindow))
-			Expect(cpmClient.GetReceiveStreamFlowControlWindow()).To(Equal(protocol.ReceiveStreamFlowControlWindow))
-			Expect(cpmClient.GetReceiveConnectionFlowControlWindow()).To(Equal(protocol.ReceiveConnectionFlowControlWindow))
+			Expect(cpm.GetReceiveStreamFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveStreamFlowControlWindow))
+			Expect(cpm.GetReceiveConnectionFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveConnectionFlowControlWindow))
+			Expect(cpmClient.GetReceiveStreamFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveStreamFlowControlWindow))
+			Expect(cpmClient.GetReceiveConnectionFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveConnectionFlowControlWindow))
 		})
 
 		It("has the correct maximum flow control windows", func() {
diff --git a/handshake/crypto_setup_client.go b/handshake/crypto_setup_client.go
index a93db9767..f26750d3e 100644
--- a/handshake/crypto_setup_client.go
+++ b/handshake/crypto_setup_client.go
@@ -12,8 +12,8 @@ import (
 	"time"
 
 	"github.com/lucas-clemente/quic-go/crypto"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
diff --git a/handshake/crypto_setup_client_test.go b/handshake/crypto_setup_client_test.go
index c689a8c41..3f12d3481 100644
--- a/handshake/crypto_setup_client_test.go
+++ b/handshake/crypto_setup_client_test.go
@@ -8,8 +8,8 @@ import (
 	"time"
 
 	"github.com/lucas-clemente/quic-go/crypto"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
diff --git a/handshake/crypto_setup_server.go b/handshake/crypto_setup_server.go
index 96170d0a5..e10abdb32 100644
--- a/handshake/crypto_setup_server.go
+++ b/handshake/crypto_setup_server.go
@@ -10,8 +10,8 @@ import (
 	"sync"
 
 	"github.com/lucas-clemente/quic-go/crypto"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
diff --git a/handshake/crypto_setup_server_test.go b/handshake/crypto_setup_server_test.go
index b73d5e036..6cbfdbafb 100644
--- a/handshake/crypto_setup_server_test.go
+++ b/handshake/crypto_setup_server_test.go
@@ -7,8 +7,8 @@ import (
 	"net"
 
 	"github.com/lucas-clemente/quic-go/crypto"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 
 	. "github.com/onsi/ginkgo"
diff --git a/handshake/ephermal_cache.go b/handshake/ephermal_cache.go
index da6724f3d..a996c3ed2 100644
--- a/handshake/ephermal_cache.go
+++ b/handshake/ephermal_cache.go
@@ -5,8 +5,8 @@ import (
 	"time"
 
 	"github.com/lucas-clemente/quic-go/crypto"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 var (
diff --git a/handshake/ephermal_cache_test.go b/handshake/ephermal_cache_test.go
index bb77b29bb..63ed90f93 100644
--- a/handshake/ephermal_cache_test.go
+++ b/handshake/ephermal_cache_test.go
@@ -4,7 +4,7 @@ import (
 	"time"
 
 	"github.com/lucas-clemente/quic-go/crypto"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/handshake/handshake_message.go b/handshake/handshake_message.go
index 1ae7ab67a..c09db26a4 100644
--- a/handshake/handshake_message.go
+++ b/handshake/handshake_message.go
@@ -7,8 +7,8 @@ import (
 	"io"
 	"sort"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
diff --git a/handshake/interface.go b/handshake/interface.go
index 751aae1e5..3448c553a 100644
--- a/handshake/interface.go
+++ b/handshake/interface.go
@@ -1,6 +1,6 @@
 package handshake
 
-import "github.com/lucas-clemente/quic-go/protocol"
+import "github.com/lucas-clemente/quic-go/internal/protocol"
 
 // Sealer seals a packet
 type Sealer func(dst, src []byte, packetNumber protocol.PacketNumber, associatedData []byte) []byte
diff --git a/integrationtests/chrome/chrome_suite_test.go b/integrationtests/chrome/chrome_suite_test.go
index 17f9aa42e..c3d13a107 100644
--- a/integrationtests/chrome/chrome_suite_test.go
+++ b/integrationtests/chrome/chrome_suite_test.go
@@ -15,8 +15,8 @@ import (
 	"time"
 
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/testserver"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 
 	_ "github.com/lucas-clemente/quic-go/integrationtests/tools/testlog"
 
diff --git a/integrationtests/chrome/chrome_test.go b/integrationtests/chrome/chrome_test.go
index b2eecbdba..728f7fdce 100644
--- a/integrationtests/chrome/chrome_test.go
+++ b/integrationtests/chrome/chrome_test.go
@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 
 	. "github.com/onsi/ginkgo"
 )
diff --git a/integrationtests/gquic/drop_test.go b/integrationtests/gquic/drop_test.go
index 6ee43de3f..a72d0b5d0 100644
--- a/integrationtests/gquic/drop_test.go
+++ b/integrationtests/gquic/drop_test.go
@@ -9,7 +9,7 @@ import (
 	_ "github.com/lucas-clemente/quic-clients" // download clients
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/proxy"
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/testserver"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
diff --git a/integrationtests/gquic/integration_test.go b/integrationtests/gquic/integration_test.go
index 2d12af4b6..5de425582 100644
--- a/integrationtests/gquic/integration_test.go
+++ b/integrationtests/gquic/integration_test.go
@@ -8,7 +8,7 @@ import (
 	"sync"
 
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/testserver"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 
 	_ "github.com/lucas-clemente/quic-clients" // download clients
 
diff --git a/integrationtests/gquic/random_rtt_test.go b/integrationtests/gquic/random_rtt_test.go
index 2a525d572..052917d68 100644
--- a/integrationtests/gquic/random_rtt_test.go
+++ b/integrationtests/gquic/random_rtt_test.go
@@ -11,7 +11,7 @@ import (
 	_ "github.com/lucas-clemente/quic-clients" // download clients
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/proxy"
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/testserver"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
diff --git a/integrationtests/gquic/rtt_test.go b/integrationtests/gquic/rtt_test.go
index 1cce41adc..29e6a1b23 100644
--- a/integrationtests/gquic/rtt_test.go
+++ b/integrationtests/gquic/rtt_test.go
@@ -10,7 +10,7 @@ import (
 	_ "github.com/lucas-clemente/quic-clients" // download clients
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/proxy"
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/testserver"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
diff --git a/integrationtests/self/client_test.go b/integrationtests/self/client_test.go
index 11bd65847..8e878e0c0 100644
--- a/integrationtests/self/client_test.go
+++ b/integrationtests/self/client_test.go
@@ -11,7 +11,7 @@ import (
 
 	"github.com/lucas-clemente/quic-go/h2quic"
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/testserver"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 	"github.com/onsi/gomega/gbytes"
diff --git a/integrationtests/self/handshake_rtt_test.go b/integrationtests/self/handshake_rtt_test.go
index 47ff6dfb7..0987ea06c 100644
--- a/integrationtests/self/handshake_rtt_test.go
+++ b/integrationtests/self/handshake_rtt_test.go
@@ -8,8 +8,8 @@ import (
 
 	quic "github.com/lucas-clemente/quic-go"
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/proxy"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 
 	"github.com/lucas-clemente/quic-go/internal/testdata"
diff --git a/integrationtests/tools/proxy/proxy.go b/integrationtests/tools/proxy/proxy.go
index bc72411d7..78af9c101 100644
--- a/integrationtests/tools/proxy/proxy.go
+++ b/integrationtests/tools/proxy/proxy.go
@@ -7,8 +7,8 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/lucas-clemente/quic-go"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 // Connection is a UDP connection
@@ -165,7 +165,7 @@ func (p *QuicProxy) runProxy() error {
 		atomic.AddUint64(&conn.incomingPacketCounter, 1)
 
 		r := bytes.NewReader(raw)
-		hdr, err := quic.ParsePublicHeader(r, protocol.PerspectiveClient, protocol.VersionWhatever)
+		hdr, err := wire.ParsePublicHeader(r, protocol.PerspectiveClient, protocol.VersionWhatever)
 		if err != nil {
 			return err
 		}
@@ -202,7 +202,7 @@ func (p *QuicProxy) runConnection(conn *connection) error {
 
 		// TODO: Switch back to using the public header once Chrome properly sets the type byte.
 		// r := bytes.NewReader(raw)
-		// , err := quic.ParsePublicHeader(r, protocol.PerspectiveServer)
+		// , err := wire.ParsePublicHeader(r, protocol.PerspectiveServer)
 		// if err != nil {
 		// return err
 		// }
diff --git a/integrationtests/tools/proxy/proxy_test.go b/integrationtests/tools/proxy/proxy_test.go
index 565a89116..88e94b165 100644
--- a/integrationtests/tools/proxy/proxy_test.go
+++ b/integrationtests/tools/proxy/proxy_test.go
@@ -9,8 +9,8 @@ import (
 
 	"fmt"
 
-	"github.com/lucas-clemente/quic-go"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -22,7 +22,7 @@ var _ = Describe("QUIC Proxy", func() {
 
 	makePacket := func(p protocol.PacketNumber, payload []byte) []byte {
 		b := &bytes.Buffer{}
-		hdr := quic.PublicHeader{
+		hdr := wire.PublicHeader{
 			PacketNumber:         p,
 			PacketNumberLen:      protocol.PacketNumberLen6,
 			ConnectionID:         1337,
diff --git a/interface.go b/interface.go
index 771d98dd1..6b3897411 100644
--- a/interface.go
+++ b/interface.go
@@ -6,9 +6,15 @@ import (
 	"net"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
+// The StreamID is the ID of a QUIC stream.
+type StreamID = protocol.StreamID
+
+// A VersionNumber is a QUIC version number.
+type VersionNumber = protocol.VersionNumber
+
 // Stream is the interface implemented by QUIC streams
 type Stream interface {
 	// Read reads data from the stream.
@@ -20,7 +26,7 @@ type Stream interface {
 	// after a fixed time limit; see SetDeadline and SetWriteDeadline.
 	io.Writer
 	io.Closer
-	StreamID() protocol.StreamID
+	StreamID() StreamID
 	// Reset closes the stream with an error.
 	Reset(error)
 	// The context is canceled as soon as the write-side of the stream is closed.
@@ -86,12 +92,11 @@ type STK struct {
 }
 
 // Config contains all configuration data needed for a QUIC server or client.
-// More config parameters (such as timeouts) will be added soon, see e.g. https://github.com/lucas-clemente/quic-go/issues/441.
 type Config struct {
 	// The QUIC versions that can be negotiated.
 	// If not set, it uses all versions available.
 	// Warning: This API should not be considered stable and will change soon.
-	Versions []protocol.VersionNumber
+	Versions []VersionNumber
 	// Ask the server to truncate the connection ID sent in the Public Header.
 	// This saves 8 bytes in the Public Header in every packet. However, if the IP address of the server changes, the connection cannot be migrated.
 	// Currently only valid for the client.
@@ -112,10 +117,10 @@ type Config struct {
 	AcceptSTK func(clientAddr net.Addr, stk *STK) bool
 	// MaxReceiveStreamFlowControlWindow is the maximum stream-level flow control window for receiving data.
 	// If this value is zero, it will default to 1 MB for the server and 6 MB for the client.
-	MaxReceiveStreamFlowControlWindow protocol.ByteCount
+	MaxReceiveStreamFlowControlWindow uint64
 	// MaxReceiveConnectionFlowControlWindow is the connection-level flow control window for receiving data.
 	// If this value is zero, it will default to 1.5 MB for the server and 15 MB for the client.
-	MaxReceiveConnectionFlowControlWindow protocol.ByteCount
+	MaxReceiveConnectionFlowControlWindow uint64
 	// KeepAlive defines whether this peer will periodically send PING frames to keep the connection alive.
 	KeepAlive bool
 }
diff --git a/flowcontrol/flow_control_manager.go b/internal/flowcontrol/flow_control_manager.go
similarity index 99%
rename from flowcontrol/flow_control_manager.go
rename to internal/flowcontrol/flow_control_manager.go
index 9362d60a1..f11c75cf8 100644
--- a/flowcontrol/flow_control_manager.go
+++ b/internal/flowcontrol/flow_control_manager.go
@@ -7,8 +7,8 @@ import (
 
 	"github.com/lucas-clemente/quic-go/congestion"
 	"github.com/lucas-clemente/quic-go/handshake"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
diff --git a/flowcontrol/flow_control_manager_test.go b/internal/flowcontrol/flow_control_manager_test.go
similarity index 99%
rename from flowcontrol/flow_control_manager_test.go
rename to internal/flowcontrol/flow_control_manager_test.go
index 4911167f6..e8cfa583a 100644
--- a/flowcontrol/flow_control_manager_test.go
+++ b/internal/flowcontrol/flow_control_manager_test.go
@@ -5,7 +5,7 @@ import (
 
 	"github.com/lucas-clemente/quic-go/congestion"
 	"github.com/lucas-clemente/quic-go/internal/mocks"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
diff --git a/flowcontrol/flow_controller.go b/internal/flowcontrol/flow_controller.go
similarity index 99%
rename from flowcontrol/flow_controller.go
rename to internal/flowcontrol/flow_controller.go
index 387ee05b9..e940f79aa 100644
--- a/flowcontrol/flow_controller.go
+++ b/internal/flowcontrol/flow_controller.go
@@ -6,8 +6,8 @@ import (
 
 	"github.com/lucas-clemente/quic-go/congestion"
 	"github.com/lucas-clemente/quic-go/handshake"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 type flowController struct {
diff --git a/flowcontrol/flow_controller_test.go b/internal/flowcontrol/flow_controller_test.go
similarity index 99%
rename from flowcontrol/flow_controller_test.go
rename to internal/flowcontrol/flow_controller_test.go
index b364ad1b8..3d324ae9a 100644
--- a/flowcontrol/flow_controller_test.go
+++ b/internal/flowcontrol/flow_controller_test.go
@@ -5,7 +5,7 @@ import (
 
 	"github.com/lucas-clemente/quic-go/congestion"
 	"github.com/lucas-clemente/quic-go/internal/mocks"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/flowcontrol/flowcontrol_suite_test.go b/internal/flowcontrol/flowcontrol_suite_test.go
similarity index 100%
rename from flowcontrol/flowcontrol_suite_test.go
rename to internal/flowcontrol/flowcontrol_suite_test.go
diff --git a/flowcontrol/interface.go b/internal/flowcontrol/interface.go
similarity index 94%
rename from flowcontrol/interface.go
rename to internal/flowcontrol/interface.go
index e1ea3fac6..1b29bd785 100644
--- a/flowcontrol/interface.go
+++ b/internal/flowcontrol/interface.go
@@ -1,6 +1,6 @@
 package flowcontrol
 
-import "github.com/lucas-clemente/quic-go/protocol"
+import "github.com/lucas-clemente/quic-go/internal/protocol"
 
 // WindowUpdate provides the data for WindowUpdateFrames.
 type WindowUpdate struct {
diff --git a/internal/mocks/cpm.go b/internal/mocks/cpm.go
index 686928f63..4abe665df 100644
--- a/internal/mocks/cpm.go
+++ b/internal/mocks/cpm.go
@@ -4,10 +4,11 @@
 package mocks
 
 import (
+	time "time"
+
 	gomock "github.com/golang/mock/gomock"
 	handshake "github.com/lucas-clemente/quic-go/handshake"
-	protocol "github.com/lucas-clemente/quic-go/protocol"
-	time "time"
+	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // Mock of ConnectionParametersManager interface
diff --git a/internal/mocks/gen.go b/internal/mocks/gen.go
index e77844769..7e0cc7cca 100644
--- a/internal/mocks/gen.go
+++ b/internal/mocks/gen.go
@@ -1,4 +1,4 @@
 package mocks
 
-//go:generate mockgen -destination mocks_fc/flow_control_manager.go -package mocks_fc github.com/lucas-clemente/quic-go/flowcontrol FlowControlManager
+//go:generate mockgen -destination mocks_fc/flow_control_manager.go -package mocks_fc github.com/lucas-clemente/quic-go/internal/flowcontrol FlowControlManager
 //go:generate mockgen -destination cpm.go -package mocks github.com/lucas-clemente/quic-go/handshake ConnectionParametersManager
diff --git a/internal/mocks/mocks_fc/flow_control_manager.go b/internal/mocks/mocks_fc/flow_control_manager.go
index d18bf48fc..490fd9cac 100644
--- a/internal/mocks/mocks_fc/flow_control_manager.go
+++ b/internal/mocks/mocks_fc/flow_control_manager.go
@@ -1,12 +1,12 @@
 // Automatically generated by MockGen. DO NOT EDIT!
-// Source: github.com/lucas-clemente/quic-go/flowcontrol (interfaces: FlowControlManager)
+// Source: github.com/lucas-clemente/quic-go/internal/flowcontrol (interfaces: FlowControlManager)
 
 package mocks_fc
 
 import (
 	gomock "github.com/golang/mock/gomock"
-	flowcontrol "github.com/lucas-clemente/quic-go/flowcontrol"
-	protocol "github.com/lucas-clemente/quic-go/protocol"
+	flowcontrol "github.com/lucas-clemente/quic-go/internal/flowcontrol"
+	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // Mock of FlowControlManager interface
diff --git a/protocol/encryption_level.go b/internal/protocol/encryption_level.go
similarity index 100%
rename from protocol/encryption_level.go
rename to internal/protocol/encryption_level.go
diff --git a/protocol/encryption_level_test.go b/internal/protocol/encryption_level_test.go
similarity index 100%
rename from protocol/encryption_level_test.go
rename to internal/protocol/encryption_level_test.go
diff --git a/protocol/packet_number.go b/internal/protocol/packet_number.go
similarity index 100%
rename from protocol/packet_number.go
rename to internal/protocol/packet_number.go
diff --git a/protocol/packet_number_test.go b/internal/protocol/packet_number_test.go
similarity index 100%
rename from protocol/packet_number_test.go
rename to internal/protocol/packet_number_test.go
diff --git a/protocol/perspective.go b/internal/protocol/perspective.go
similarity index 100%
rename from protocol/perspective.go
rename to internal/protocol/perspective.go
diff --git a/protocol/protocol.go b/internal/protocol/protocol.go
similarity index 100%
rename from protocol/protocol.go
rename to internal/protocol/protocol.go
diff --git a/protocol/protocol_suite_test.go b/internal/protocol/protocol_suite_test.go
similarity index 100%
rename from protocol/protocol_suite_test.go
rename to internal/protocol/protocol_suite_test.go
diff --git a/protocol/server_parameters.go b/internal/protocol/server_parameters.go
similarity index 93%
rename from protocol/server_parameters.go
rename to internal/protocol/server_parameters.go
index 2b0c38728..377f5afaf 100644
--- a/protocol/server_parameters.go
+++ b/internal/protocol/server_parameters.go
@@ -33,27 +33,27 @@ const AckSendDelay = 25 * time.Millisecond
 
 // ReceiveStreamFlowControlWindow is the stream-level flow control window for receiving data
 // This is the value that Google servers are using
-const ReceiveStreamFlowControlWindow ByteCount = (1 << 10) * 32 // 32 kB
+const ReceiveStreamFlowControlWindow = (1 << 10) * 32 // 32 kB
 
 // ReceiveConnectionFlowControlWindow is the connection-level flow control window for receiving data
 // This is the value that Google servers are using
-const ReceiveConnectionFlowControlWindow ByteCount = (1 << 10) * 48 // 48 kB
+const ReceiveConnectionFlowControlWindow = (1 << 10) * 48 // 48 kB
 
 // DefaultMaxReceiveStreamFlowControlWindowServer is the default maximum stream-level flow control window for receiving data, for the server
 // This is the value that Google servers are using
-const DefaultMaxReceiveStreamFlowControlWindowServer ByteCount = 1 * (1 << 20) // 1 MB
+const DefaultMaxReceiveStreamFlowControlWindowServer = 1 * (1 << 20) // 1 MB
 
 // DefaultMaxReceiveConnectionFlowControlWindowServer is the default connection-level flow control window for receiving data, for the server
 // This is the value that Google servers are using
-const DefaultMaxReceiveConnectionFlowControlWindowServer ByteCount = 1.5 * (1 << 20) // 1.5 MB
+const DefaultMaxReceiveConnectionFlowControlWindowServer = 1.5 * (1 << 20) // 1.5 MB
 
 // DefaultMaxReceiveStreamFlowControlWindowClient is the default maximum stream-level flow control window for receiving data, for the client
 // This is the value that Chromium is using
-const DefaultMaxReceiveStreamFlowControlWindowClient ByteCount = 6 * (1 << 20) // 6 MB
+const DefaultMaxReceiveStreamFlowControlWindowClient = 6 * (1 << 20) // 6 MB
 
 // DefaultMaxReceiveConnectionFlowControlWindowClient is the default connection-level flow control window for receiving data, for the client
 // This is the value that Google servers are using
-const DefaultMaxReceiveConnectionFlowControlWindowClient ByteCount = 15 * (1 << 20) // 15 MB
+const DefaultMaxReceiveConnectionFlowControlWindowClient = 15 * (1 << 20) // 15 MB
 
 // ConnectionFlowControlMultiplier determines how much larger the connection flow control windows needs to be relative to any stream's flow control window
 // This is the value that Chromium is using
diff --git a/protocol/version.go b/internal/protocol/version.go
similarity index 100%
rename from protocol/version.go
rename to internal/protocol/version.go
diff --git a/internal/protocol/version.go.orig b/internal/protocol/version.go.orig
new file mode 100644
index 000000000..80a5eae28
--- /dev/null
+++ b/internal/protocol/version.go.orig
@@ -0,0 +1,61 @@
+package protocol
+
+// VersionNumber is a version number as int
+type VersionNumber int
+
+// The version numbers, making grepping easier
+const (
+	Version35 VersionNumber = 35 + iota
+	Version36
+	Version37
+<<<<<<< Updated upstream
+=======
+	Version38
+>>>>>>> Stashed changes
+	Version39
+	VersionWhatever    VersionNumber = 0 // for when the version doesn't matter
+	VersionUnsupported VersionNumber = -1
+	VersionUnknown     VersionNumber = -2
+)
+
+// SupportedVersions lists the versions that the server supports
+// must be in sorted descending order
+var SupportedVersions = []VersionNumber{
+	Version39, //Version37, Version36, Version35,
+}
+
+// VersionNumberToTag maps version numbers ('32') to tags ('Q032')
+func VersionNumberToTag(vn VersionNumber) uint32 {
+	v := uint32(vn)
+	return 'Q' + ((v/100%10)+'0')<<8 + ((v/10%10)+'0')<<16 + ((v%10)+'0')<<24
+}
+
+// VersionTagToNumber is built from VersionNumberToTag in init()
+func VersionTagToNumber(v uint32) VersionNumber {
+	return VersionNumber(((v>>8)&0xff-'0')*100 + ((v>>16)&0xff-'0')*10 + ((v>>24)&0xff - '0'))
+}
+
+// IsSupportedVersion returns true if the server supports this version
+func IsSupportedVersion(supported []VersionNumber, v VersionNumber) bool {
+	for _, t := range supported {
+		if t == v {
+			return true
+		}
+	}
+	return false
+}
+
+// ChooseSupportedVersion finds the best version in the overlap of ours and theirs
+// ours is a slice of versions that we support, sorted by our preference (descending)
+// theirs is a slice of versions offered by the peer. The order does not matter
+// if no suitable version is found, it returns VersionUnsupported
+func ChooseSupportedVersion(ours, theirs []VersionNumber) VersionNumber {
+	for _, ourVer := range ours {
+		for _, theirVer := range theirs {
+			if ourVer == theirVer {
+				return ourVer
+			}
+		}
+	}
+	return VersionUnsupported
+}
diff --git a/protocol/version_test.go b/internal/protocol/version_test.go
similarity index 100%
rename from protocol/version_test.go
rename to internal/protocol/version_test.go
diff --git a/internal/utils/byteorder.go b/internal/utils/byteorder.go
index bfba07386..1598fac80 100644
--- a/internal/utils/byteorder.go
+++ b/internal/utils/byteorder.go
@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"io"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // A ByteOrder specifies how to convert byte sequences into 16-, 32-, or 64-bit unsigned integers.
diff --git a/internal/utils/byteorder_test.go b/internal/utils/byteorder_test.go
index a1ddb8b0e..16ba55c29 100644
--- a/internal/utils/byteorder_test.go
+++ b/internal/utils/byteorder_test.go
@@ -1,7 +1,7 @@
 package utils
 
 import (
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/internal/utils/connection_id.go b/internal/utils/connection_id.go
index c2252e6ed..b4af4e780 100644
--- a/internal/utils/connection_id.go
+++ b/internal/utils/connection_id.go
@@ -4,7 +4,7 @@ import (
 	"crypto/rand"
 	"encoding/binary"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // GenerateConnectionID generates a connection ID using cryptographic random
diff --git a/internal/utils/minmax.go b/internal/utils/minmax.go
index 6e23df5a5..c984a3c76 100644
--- a/internal/utils/minmax.go
+++ b/internal/utils/minmax.go
@@ -4,7 +4,7 @@ import (
 	"math"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // InfDuration is a duration of infinite length
diff --git a/internal/utils/minmax_test.go b/internal/utils/minmax_test.go
index 7d3df2210..f9041472c 100644
--- a/internal/utils/minmax_test.go
+++ b/internal/utils/minmax_test.go
@@ -3,7 +3,7 @@ package utils
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/internal/utils/packet_interval.go b/internal/utils/packet_interval.go
index 09800b6b6..f49b0c426 100644
--- a/internal/utils/packet_interval.go
+++ b/internal/utils/packet_interval.go
@@ -1,6 +1,6 @@
 package utils
 
-import "github.com/lucas-clemente/quic-go/protocol"
+import "github.com/lucas-clemente/quic-go/internal/protocol"
 
 // PacketInterval is an interval from one PacketNumber to the other
 // +gen linkedlist
diff --git a/internal/utils/streamframe_interval.go b/internal/utils/streamframe_interval.go
index c918b62eb..3c8325b25 100644
--- a/internal/utils/streamframe_interval.go
+++ b/internal/utils/streamframe_interval.go
@@ -1,6 +1,6 @@
 package utils
 
-import "github.com/lucas-clemente/quic-go/protocol"
+import "github.com/lucas-clemente/quic-go/internal/protocol"
 
 // ByteInterval is an interval from one ByteCount to the other
 // +gen linkedlist
diff --git a/frames/ack_frame.go b/internal/wire/ack_frame.go
similarity index 99%
rename from frames/ack_frame.go
rename to internal/wire/ack_frame.go
index 06aafaefb..c8a3f76cb 100644
--- a/frames/ack_frame.go
+++ b/internal/wire/ack_frame.go
@@ -1,12 +1,12 @@
-package frames
+package wire
 
 import (
 	"bytes"
 	"errors"
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 var (
diff --git a/frames/ack_frame_test.go b/internal/wire/ack_frame_test.go
similarity index 99%
rename from frames/ack_frame_test.go
rename to internal/wire/ack_frame_test.go
index 216aec403..e9f0ab36b 100644
--- a/frames/ack_frame_test.go
+++ b/internal/wire/ack_frame_test.go
@@ -1,4 +1,4 @@
-package frames
+package wire
 
 import (
 	"bytes"
@@ -6,7 +6,7 @@ import (
 	"io"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/frames/ack_range.go b/internal/wire/ack_range.go
similarity index 64%
rename from frames/ack_range.go
rename to internal/wire/ack_range.go
index ac65d33ea..2f9fbe3ea 100644
--- a/frames/ack_range.go
+++ b/internal/wire/ack_range.go
@@ -1,6 +1,6 @@
-package frames
+package wire
 
-import "github.com/lucas-clemente/quic-go/protocol"
+import "github.com/lucas-clemente/quic-go/internal/protocol"
 
 // AckRange is an ACK range
 type AckRange struct {
diff --git a/frames/blocked_frame.go b/internal/wire/blocked_frame.go
similarity index 93%
rename from frames/blocked_frame.go
rename to internal/wire/blocked_frame.go
index 010407a8d..76e38f025 100644
--- a/frames/blocked_frame.go
+++ b/internal/wire/blocked_frame.go
@@ -1,10 +1,10 @@
-package frames
+package wire
 
 import (
 	"bytes"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 // A BlockedFrame in QUIC
diff --git a/frames/blocked_frame_test.go b/internal/wire/blocked_frame_test.go
similarity index 96%
rename from frames/blocked_frame_test.go
rename to internal/wire/blocked_frame_test.go
index dd990d079..ac7048a3e 100644
--- a/frames/blocked_frame_test.go
+++ b/internal/wire/blocked_frame_test.go
@@ -1,9 +1,9 @@
-package frames
+package wire
 
 import (
 	"bytes"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/frames/connection_close_frame.go b/internal/wire/connection_close_frame.go
similarity index 96%
rename from frames/connection_close_frame.go
rename to internal/wire/connection_close_frame.go
index e70aad75c..96c25c1ea 100644
--- a/frames/connection_close_frame.go
+++ b/internal/wire/connection_close_frame.go
@@ -1,4 +1,4 @@
-package frames
+package wire
 
 import (
 	"bytes"
@@ -6,8 +6,8 @@ import (
 	"io"
 	"math"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
diff --git a/frames/connection_close_frame_test.go b/internal/wire/connection_close_frame_test.go
similarity index 99%
rename from frames/connection_close_frame_test.go
rename to internal/wire/connection_close_frame_test.go
index ff788b792..351fa843f 100644
--- a/frames/connection_close_frame_test.go
+++ b/internal/wire/connection_close_frame_test.go
@@ -1,10 +1,10 @@
-package frames
+package wire
 
 import (
 	"bytes"
 	"strings"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
diff --git a/frames/frame.go b/internal/wire/frame.go
similarity index 74%
rename from frames/frame.go
rename to internal/wire/frame.go
index 464e6693a..f31f5bf28 100644
--- a/frames/frame.go
+++ b/internal/wire/frame.go
@@ -1,9 +1,9 @@
-package frames
+package wire
 
 import (
 	"bytes"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // A Frame in QUIC
diff --git a/frames/goaway_frame.go b/internal/wire/goaway_frame.go
similarity index 96%
rename from frames/goaway_frame.go
rename to internal/wire/goaway_frame.go
index 46a91d4c0..5332210d8 100644
--- a/frames/goaway_frame.go
+++ b/internal/wire/goaway_frame.go
@@ -1,11 +1,11 @@
-package frames
+package wire
 
 import (
 	"bytes"
 	"io"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
diff --git a/frames/goaway_frame_test.go b/internal/wire/goaway_frame_test.go
similarity index 98%
rename from frames/goaway_frame_test.go
rename to internal/wire/goaway_frame_test.go
index 0b12ad121..f9b02db19 100644
--- a/frames/goaway_frame_test.go
+++ b/internal/wire/goaway_frame_test.go
@@ -1,9 +1,9 @@
-package frames
+package wire
 
 import (
 	"bytes"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 
 	. "github.com/onsi/ginkgo"
diff --git a/internal/wire/log.go b/internal/wire/log.go
new file mode 100644
index 000000000..0e72ea98a
--- /dev/null
+++ b/internal/wire/log.go
@@ -0,0 +1,28 @@
+package wire
+
+import "github.com/lucas-clemente/quic-go/internal/utils"
+
+// LogFrame logs a frame, either sent or received
+func LogFrame(frame Frame, sent bool) {
+	if !utils.Debug() {
+		return
+	}
+	dir := "<-"
+	if sent {
+		dir = "->"
+	}
+	switch f := frame.(type) {
+	case *StreamFrame:
+		utils.Debugf("\t%s &wire.StreamFrame{StreamID: %d, FinBit: %t, Offset: 0x%x, Data length: 0x%x, Offset + Data length: 0x%x}", dir, f.StreamID, f.FinBit, f.Offset, f.DataLen(), f.Offset+f.DataLen())
+	case *StopWaitingFrame:
+		if sent {
+			utils.Debugf("\t%s &wire.StopWaitingFrame{LeastUnacked: 0x%x, PacketNumberLen: 0x%x}", dir, f.LeastUnacked, f.PacketNumberLen)
+		} else {
+			utils.Debugf("\t%s &wire.StopWaitingFrame{LeastUnacked: 0x%x}", dir, f.LeastUnacked)
+		}
+	case *AckFrame:
+		utils.Debugf("\t%s &wire.AckFrame{LargestAcked: 0x%x, LowestAcked: 0x%x, AckRanges: %#v, DelayTime: %s}", dir, f.LargestAcked, f.LowestAcked, f.AckRanges, f.DelayTime.String())
+	default:
+		utils.Debugf("\t%s %#v", dir, frame)
+	}
+}
diff --git a/frames/log_test.go b/internal/wire/log_test.go
similarity index 62%
rename from frames/log_test.go
rename to internal/wire/log_test.go
index 49a6c3d02..33547efaa 100644
--- a/frames/log_test.go
+++ b/internal/wire/log_test.go
@@ -1,4 +1,4 @@
-package frames
+package wire
 
 import (
 	"bytes"
@@ -6,8 +6,8 @@ import (
 	"os"
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -37,12 +37,12 @@ var _ = Describe("Frame logging", func() {
 
 	It("logs sent frames", func() {
 		LogFrame(&RstStreamFrame{}, true)
-		Expect(buf.Bytes()).To(ContainSubstring("\t-> &frames.RstStreamFrame{StreamID:0x0, ErrorCode:0x0, ByteOffset:0x0}\n"))
+		Expect(buf.Bytes()).To(ContainSubstring("\t-> &wire.RstStreamFrame{StreamID:0x0, ErrorCode:0x0, ByteOffset:0x0}\n"))
 	})
 
 	It("logs received frames", func() {
 		LogFrame(&RstStreamFrame{}, false)
-		Expect(buf.Bytes()).To(ContainSubstring("\t<- &frames.RstStreamFrame{StreamID:0x0, ErrorCode:0x0, ByteOffset:0x0}\n"))
+		Expect(buf.Bytes()).To(ContainSubstring("\t<- &wire.RstStreamFrame{StreamID:0x0, ErrorCode:0x0, ByteOffset:0x0}\n"))
 	})
 
 	It("logs stream frames", func() {
@@ -52,7 +52,7 @@ var _ = Describe("Frame logging", func() {
 			Data:     bytes.Repeat([]byte{'f'}, 0x100),
 		}
 		LogFrame(frame, false)
-		Expect(buf.Bytes()).To(ContainSubstring("\t<- &frames.StreamFrame{StreamID: 42, FinBit: false, Offset: 0x1337, Data length: 0x100, Offset + Data length: 0x1437}\n"))
+		Expect(buf.Bytes()).To(ContainSubstring("\t<- &wire.StreamFrame{StreamID: 42, FinBit: false, Offset: 0x1337, Data length: 0x100, Offset + Data length: 0x1437}\n"))
 	})
 
 	It("logs ACK frames", func() {
@@ -62,7 +62,7 @@ var _ = Describe("Frame logging", func() {
 			DelayTime:    1 * time.Millisecond,
 		}
 		LogFrame(frame, false)
-		Expect(buf.Bytes()).To(ContainSubstring("\t<- &frames.AckFrame{LargestAcked: 0x1337, LowestAcked: 0x42, AckRanges: []frames.AckRange(nil), DelayTime: 1ms}\n"))
+		Expect(buf.Bytes()).To(ContainSubstring("\t<- &wire.AckFrame{LargestAcked: 0x1337, LowestAcked: 0x42, AckRanges: []wire.AckRange(nil), DelayTime: 1ms}\n"))
 	})
 
 	It("logs incoming StopWaiting frames", func() {
@@ -70,7 +70,7 @@ var _ = Describe("Frame logging", func() {
 			LeastUnacked: 0x1337,
 		}
 		LogFrame(frame, false)
-		Expect(buf.Bytes()).To(ContainSubstring("\t<- &frames.StopWaitingFrame{LeastUnacked: 0x1337}\n"))
+		Expect(buf.Bytes()).To(ContainSubstring("\t<- &wire.StopWaitingFrame{LeastUnacked: 0x1337}\n"))
 	})
 
 	It("logs outgoing StopWaiting frames", func() {
@@ -79,6 +79,6 @@ var _ = Describe("Frame logging", func() {
 			PacketNumberLen: protocol.PacketNumberLen4,
 		}
 		LogFrame(frame, true)
-		Expect(buf.Bytes()).To(ContainSubstring("\t-> &frames.StopWaitingFrame{LeastUnacked: 0x1337, PacketNumberLen: 0x4}\n"))
+		Expect(buf.Bytes()).To(ContainSubstring("\t-> &wire.StopWaitingFrame{LeastUnacked: 0x1337, PacketNumberLen: 0x4}\n"))
 	})
 })
diff --git a/frames/ping_frame.go b/internal/wire/ping_frame.go
similarity index 89%
rename from frames/ping_frame.go
rename to internal/wire/ping_frame.go
index c08362d7d..2a09c33a7 100644
--- a/frames/ping_frame.go
+++ b/internal/wire/ping_frame.go
@@ -1,9 +1,9 @@
-package frames
+package wire
 
 import (
 	"bytes"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // A PingFrame is a ping frame
diff --git a/frames/ping_frame_test.go b/internal/wire/ping_frame_test.go
similarity index 92%
rename from frames/ping_frame_test.go
rename to internal/wire/ping_frame_test.go
index f3e89b250..d0627a6fc 100644
--- a/frames/ping_frame_test.go
+++ b/internal/wire/ping_frame_test.go
@@ -1,9 +1,9 @@
-package frames
+package wire
 
 import (
 	"bytes"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/public_header.go b/internal/wire/public_header.go
similarity index 91%
rename from public_header.go
rename to internal/wire/public_header.go
index 9140fc8c6..adc1a11ac 100644
--- a/public_header.go
+++ b/internal/wire/public_header.go
@@ -1,23 +1,23 @@
-package quic
+package wire
 
 import (
 	"bytes"
 	"errors"
 	"io"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
 var (
-	errPacketNumberLenNotSet             = errors.New("PublicHeader: PacketNumberLen not set")
+	// ErrPacketWithUnknownVersion occurs when a packet with an unknown version is parsed.
+	// This can happen when the server is restarted. The client will send a packet without a version number.
+	ErrPacketWithUnknownVersion          = errors.New("PublicHeader: Received a packet without version number, that we don't know the version for")
 	errResetAndVersionFlagSet            = errors.New("PublicHeader: Reset Flag and Version Flag should not be set at the same time")
 	errReceivedTruncatedConnectionID     = qerr.Error(qerr.InvalidPacketHeader, "receiving packets with truncated ConnectionID is not supported")
 	errInvalidConnectionID               = qerr.Error(qerr.InvalidPacketHeader, "connection ID cannot be 0")
 	errGetLengthNotForVersionNegotiation = errors.New("PublicHeader: GetLength cannot be called for VersionNegotiation packets")
-	// this can happen when the server is restarted. The client will send a packet without a version number
-	errPacketWithUnknownVersion = errors.New("PublicHeader: Received a packet without version number, that we don't know the version for")
 )
 
 // The PublicHeader of a QUIC packet. Warning: This struct should not be considered stable and will change soon.
@@ -93,10 +93,6 @@ func (h *PublicHeader) Write(b *bytes.Buffer, version protocol.VersionNumber, pe
 		return nil
 	}
 
-	if h.PacketNumberLen != protocol.PacketNumberLen1 && h.PacketNumberLen != protocol.PacketNumberLen2 && h.PacketNumberLen != protocol.PacketNumberLen4 && h.PacketNumberLen != protocol.PacketNumberLen6 {
-		return errPacketNumberLenNotSet
-	}
-
 	switch h.PacketNumberLen {
 	case protocol.PacketNumberLen1:
 		b.WriteByte(uint8(h.PacketNumber))
@@ -107,15 +103,15 @@ func (h *PublicHeader) Write(b *bytes.Buffer, version protocol.VersionNumber, pe
 	case protocol.PacketNumberLen6:
 		utils.GetByteOrder(version).WriteUint48(b, uint64(h.PacketNumber)&(1<<48-1))
 	default:
-		return errPacketNumberLenNotSet
+		return errors.New("PublicHeader: PacketNumberLen not set")
 	}
 
 	return nil
 }
 
-// peekConnectionID parses the connection ID from a QUIC packet's public header.
+// PeekConnectionID parses the connection ID from a QUIC packet's public header.
 // If no error occurs, it restores the read position in the bytes.Reader.
-func peekConnectionID(b *bytes.Reader, packetSentBy protocol.Perspective) (protocol.ConnectionID, error) {
+func PeekConnectionID(b *bytes.Reader, packetSentBy protocol.Perspective) (protocol.ConnectionID, error) {
 	var connectionID protocol.ConnectionID
 	publicFlagByte, err := b.ReadByte()
 	if err != nil {
@@ -156,7 +152,7 @@ func ParsePublicHeader(b *bytes.Reader, packetSentBy protocol.Perspective, versi
 	header.ResetFlag = publicFlagByte&0x02 > 0
 	header.VersionFlag = publicFlagByte&0x01 > 0
 	if version == protocol.VersionUnknown && !(header.VersionFlag || header.ResetFlag) {
-		return nil, errPacketWithUnknownVersion
+		return nil, ErrPacketWithUnknownVersion
 	}
 
 	// TODO: activate this check once Chrome sends the correct value
diff --git a/public_header_test.go b/internal/wire/public_header_test.go
similarity index 97%
rename from public_header_test.go
rename to internal/wire/public_header_test.go
index 6d1512341..3265617c5 100644
--- a/public_header_test.go
+++ b/internal/wire/public_header_test.go
@@ -1,11 +1,11 @@
-package quic
+package wire
 
 import (
 	"bytes"
 	"encoding/binary"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -15,14 +15,14 @@ var _ = Describe("Public Header", func() {
 	Context("parsing the connection ID", func() {
 		It("does not accept truncated connection ID as a server", func() {
 			b := bytes.NewReader([]byte{0x00, 0x01})
-			_, err := peekConnectionID(b, protocol.PerspectiveClient)
+			_, err := PeekConnectionID(b, protocol.PerspectiveClient)
 			Expect(err).To(MatchError(errReceivedTruncatedConnectionID))
 		})
 
 		It("gets the connection ID", func() {
 			b := bytes.NewReader([]byte{0x09, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0x51, 0x30, 0x33, 0x34, 0x01})
 			len := b.Len()
-			connID, err := peekConnectionID(b, protocol.PerspectiveClient)
+			connID, err := PeekConnectionID(b, protocol.PerspectiveClient)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(connID).To(Equal(protocol.ConnectionID(0x4cfa9f9b668619f6)))
 			Expect(b.Len()).To(Equal(len))
@@ -30,20 +30,20 @@ var _ = Describe("Public Header", func() {
 
 		It("errors if the Public Header is too short", func() {
 			b := bytes.NewReader([]byte{0x09, 0xf6, 0x19, 0x86, 0x66, 0x9b})
-			_, err := peekConnectionID(b, protocol.PerspectiveClient)
+			_, err := PeekConnectionID(b, protocol.PerspectiveClient)
 			Expect(err).To(HaveOccurred())
 		})
 
 		It("errors if the Public Header is empty", func() {
 			b := bytes.NewReader([]byte{})
-			_, err := peekConnectionID(b, protocol.PerspectiveClient)
+			_, err := PeekConnectionID(b, protocol.PerspectiveClient)
 			Expect(err).To(HaveOccurred())
 		})
 
 		It("accepts a truncated connection ID as a client", func() {
 			b := bytes.NewReader([]byte{0x00, 0x01})
 			len := b.Len()
-			connID, err := peekConnectionID(b, protocol.PerspectiveServer)
+			connID, err := PeekConnectionID(b, protocol.PerspectiveServer)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(connID).To(BeZero())
 			Expect(b.Len()).To(Equal(len))
@@ -116,7 +116,7 @@ var _ = Describe("Public Header", func() {
 		It("returns an unknown version error when receiving a packet without a version for which the version is not given", func() {
 			b := bytes.NewReader([]byte{0x10, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0xef})
 			_, err := ParsePublicHeader(b, protocol.PerspectiveServer, protocol.VersionUnknown)
-			Expect(err).To(MatchError(errPacketWithUnknownVersion))
+			Expect(err).To(MatchError(ErrPacketWithUnknownVersion))
 		})
 
 		PIt("rejects diversification nonces sent by the client", func() {
@@ -136,7 +136,7 @@ var _ = Describe("Public Header", func() {
 			}
 
 			It("parses version negotiation packets sent by the server", func() {
-				b := bytes.NewReader(composeVersionNegotiation(0x1337, protocol.SupportedVersions))
+				b := bytes.NewReader(ComposeVersionNegotiation(0x1337, protocol.SupportedVersions))
 				hdr, err := ParsePublicHeader(b, protocol.PerspectiveServer, protocol.VersionUnknown)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(hdr.VersionFlag).To(BeTrue())
@@ -169,7 +169,7 @@ var _ = Describe("Public Header", func() {
 			})
 
 			It("errors on invalid version tags", func() {
-				data := composeVersionNegotiation(0x1337, protocol.SupportedVersions)
+				data := ComposeVersionNegotiation(0x1337, protocol.SupportedVersions)
 				data = append(data, []byte{0x13, 0x37}...)
 				b := bytes.NewReader(data)
 				_, err := ParsePublicHeader(b, protocol.PerspectiveServer, protocol.VersionUnknown)
@@ -300,7 +300,7 @@ var _ = Describe("Public Header", func() {
 			}
 			b := &bytes.Buffer{}
 			err := hdr.Write(b, protocol.VersionWhatever, protocol.PerspectiveServer)
-			Expect(err).To(MatchError(errPacketNumberLenNotSet))
+			Expect(err).To(MatchError("PublicHeader: PacketNumberLen not set"))
 		})
 
 		It("truncates the connection ID", func() {
@@ -526,7 +526,7 @@ var _ = Describe("Public Header", func() {
 					PacketNumber: 0xDECAFBAD,
 				}
 				err := hdr.Write(b, protocol.VersionWhatever, protocol.PerspectiveServer)
-				Expect(err).To(MatchError(errPacketNumberLenNotSet))
+				Expect(err).To(MatchError("PublicHeader: PacketNumberLen not set"))
 			})
 
 			Context("in little endian", func() {
diff --git a/public_reset.go b/internal/wire/public_reset.go
similarity index 70%
rename from public_reset.go
rename to internal/wire/public_reset.go
index 163e3bbd5..e7a5f0b4d 100644
--- a/public_reset.go
+++ b/internal/wire/public_reset.go
@@ -1,4 +1,4 @@
-package quic
+package wire
 
 import (
 	"bytes"
@@ -6,16 +6,18 @@ import (
 	"errors"
 
 	"github.com/lucas-clemente/quic-go/handshake"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
-type publicReset struct {
-	rejectedPacketNumber protocol.PacketNumber
-	nonce                uint64
+// A PublicReset is a PUBLIC_RESET
+type PublicReset struct {
+	RejectedPacketNumber protocol.PacketNumber
+	Nonce                uint64
 }
 
-func writePublicReset(connectionID protocol.ConnectionID, rejectedPacketNumber protocol.PacketNumber, nonceProof uint64) []byte {
+// WritePublicReset writes a Public Reset
+func WritePublicReset(connectionID protocol.ConnectionID, rejectedPacketNumber protocol.PacketNumber, nonceProof uint64) []byte {
 	b := &bytes.Buffer{}
 	b.WriteByte(0x0a)
 	utils.LittleEndian.WriteUint64(b, uint64(connectionID))
@@ -30,8 +32,9 @@ func writePublicReset(connectionID protocol.ConnectionID, rejectedPacketNumber p
 	return b.Bytes()
 }
 
-func parsePublicReset(r *bytes.Reader) (*publicReset, error) {
-	pr := publicReset{}
+// ParsePublicReset parses a Public Reset
+func ParsePublicReset(r *bytes.Reader) (*PublicReset, error) {
+	pr := PublicReset{}
 	msg, err := handshake.ParseHandshakeMessage(r)
 	if err != nil {
 		return nil, err
@@ -47,7 +50,7 @@ func parsePublicReset(r *bytes.Reader) (*publicReset, error) {
 	if len(rseq) != 8 {
 		return nil, errors.New("invalid RSEQ tag")
 	}
-	pr.rejectedPacketNumber = protocol.PacketNumber(binary.LittleEndian.Uint64(rseq))
+	pr.RejectedPacketNumber = protocol.PacketNumber(binary.LittleEndian.Uint64(rseq))
 
 	rnon, ok := msg.Data[handshake.TagRNON]
 	if !ok {
@@ -56,7 +59,7 @@ func parsePublicReset(r *bytes.Reader) (*publicReset, error) {
 	if len(rnon) != 8 {
 		return nil, errors.New("invalid RNON tag")
 	}
-	pr.nonce = binary.LittleEndian.Uint64(rnon)
+	pr.Nonce = binary.LittleEndian.Uint64(rnon)
 
 	return &pr, nil
 }
diff --git a/public_reset_test.go b/internal/wire/public_reset_test.go
similarity index 77%
rename from public_reset_test.go
rename to internal/wire/public_reset_test.go
index f1344ee88..fcd2f1bf2 100644
--- a/public_reset_test.go
+++ b/internal/wire/public_reset_test.go
@@ -1,11 +1,11 @@
-package quic
+package wire
 
 import (
 	"bytes"
 	"io"
 
 	"github.com/lucas-clemente/quic-go/handshake"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -13,7 +13,7 @@ import (
 var _ = Describe("public reset", func() {
 	Context("writing", func() {
 		It("writes public reset packets", func() {
-			Expect(writePublicReset(0xdeadbeef, 0x8badf00d, 0xdecafbad)).To(Equal([]byte{
+			Expect(WritePublicReset(0xdeadbeef, 0x8badf00d, 0xdecafbad)).To(Equal([]byte{
 				0x0a,
 				0xef, 0xbe, 0xad, 0xde, 0x00, 0x00, 0x00, 0x00,
 				'P', 'R', 'S', 'T',
@@ -36,21 +36,21 @@ var _ = Describe("public reset", func() {
 		})
 
 		It("parses a public reset", func() {
-			packet := writePublicReset(0xdeadbeef, 0x8badf00d, 0xdecafbad)
-			pr, err := parsePublicReset(bytes.NewReader(packet[9:])) // 1 byte Public Flag, 8 bytes connection ID
+			packet := WritePublicReset(0xdeadbeef, 0x8badf00d, 0xdecafbad)
+			pr, err := ParsePublicReset(bytes.NewReader(packet[9:])) // 1 byte Public Flag, 8 bytes connection ID
 			Expect(err).ToNot(HaveOccurred())
-			Expect(pr.nonce).To(Equal(uint64(0xdecafbad)))
-			Expect(pr.rejectedPacketNumber).To(Equal(protocol.PacketNumber(0x8badf00d)))
+			Expect(pr.Nonce).To(Equal(uint64(0xdecafbad)))
+			Expect(pr.RejectedPacketNumber).To(Equal(protocol.PacketNumber(0x8badf00d)))
 		})
 
 		It("rejects packets that it can't parse", func() {
-			_, err := parsePublicReset(bytes.NewReader([]byte{}))
+			_, err := ParsePublicReset(bytes.NewReader([]byte{}))
 			Expect(err).To(MatchError(io.EOF))
 		})
 
 		It("rejects packets with the wrong tag", func() {
 			handshake.HandshakeMessage{Tag: handshake.TagREJ, Data: nil}.Write(b)
-			_, err := parsePublicReset(bytes.NewReader(b.Bytes()))
+			_, err := ParsePublicReset(bytes.NewReader(b.Bytes()))
 			Expect(err).To(MatchError("wrong public reset tag"))
 		})
 
@@ -59,7 +59,7 @@ var _ = Describe("public reset", func() {
 				handshake.TagRSEQ: []byte{0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0x13, 0x37},
 			}
 			handshake.HandshakeMessage{Tag: handshake.TagPRST, Data: data}.Write(b)
-			_, err := parsePublicReset(bytes.NewReader(b.Bytes()))
+			_, err := ParsePublicReset(bytes.NewReader(b.Bytes()))
 			Expect(err).To(MatchError("RNON missing"))
 		})
 
@@ -69,7 +69,7 @@ var _ = Describe("public reset", func() {
 				handshake.TagRNON: []byte{0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0x13},
 			}
 			handshake.HandshakeMessage{Tag: handshake.TagPRST, Data: data}.Write(b)
-			_, err := parsePublicReset(bytes.NewReader(b.Bytes()))
+			_, err := ParsePublicReset(bytes.NewReader(b.Bytes()))
 			Expect(err).To(MatchError("invalid RNON tag"))
 		})
 
@@ -78,7 +78,7 @@ var _ = Describe("public reset", func() {
 				handshake.TagRNON: []byte{0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0x13, 0x37},
 			}
 			handshake.HandshakeMessage{Tag: handshake.TagPRST, Data: data}.Write(b)
-			_, err := parsePublicReset(bytes.NewReader(b.Bytes()))
+			_, err := ParsePublicReset(bytes.NewReader(b.Bytes()))
 			Expect(err).To(MatchError("RSEQ missing"))
 		})
 
@@ -88,7 +88,7 @@ var _ = Describe("public reset", func() {
 				handshake.TagRNON: []byte{0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0x13, 0x37},
 			}
 			handshake.HandshakeMessage{Tag: handshake.TagPRST, Data: data}.Write(b)
-			_, err := parsePublicReset(bytes.NewReader(b.Bytes()))
+			_, err := ParsePublicReset(bytes.NewReader(b.Bytes()))
 			Expect(err).To(MatchError("invalid RSEQ tag"))
 		})
 	})
diff --git a/frames/rst_stream_frame.go b/internal/wire/rst_stream_frame.go
similarity index 95%
rename from frames/rst_stream_frame.go
rename to internal/wire/rst_stream_frame.go
index 40701d595..04086f835 100644
--- a/frames/rst_stream_frame.go
+++ b/internal/wire/rst_stream_frame.go
@@ -1,10 +1,10 @@
-package frames
+package wire
 
 import (
 	"bytes"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 // A RstStreamFrame in QUIC
diff --git a/frames/rst_stream_frame_test.go b/internal/wire/rst_stream_frame_test.go
similarity index 97%
rename from frames/rst_stream_frame_test.go
rename to internal/wire/rst_stream_frame_test.go
index 97a8abe56..53c6e157a 100644
--- a/frames/rst_stream_frame_test.go
+++ b/internal/wire/rst_stream_frame_test.go
@@ -1,9 +1,9 @@
-package frames
+package wire
 
 import (
 	"bytes"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/frames/stop_waiting_frame.go b/internal/wire/stop_waiting_frame.go
similarity index 97%
rename from frames/stop_waiting_frame.go
rename to internal/wire/stop_waiting_frame.go
index 60925e5fd..9eb068dcc 100644
--- a/frames/stop_waiting_frame.go
+++ b/internal/wire/stop_waiting_frame.go
@@ -1,11 +1,11 @@
-package frames
+package wire
 
 import (
 	"bytes"
 	"errors"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
diff --git a/frames/stop_waiting_frame_test.go b/internal/wire/stop_waiting_frame_test.go
similarity index 99%
rename from frames/stop_waiting_frame_test.go
rename to internal/wire/stop_waiting_frame_test.go
index 5b9de9988..02e7dd3f6 100644
--- a/frames/stop_waiting_frame_test.go
+++ b/internal/wire/stop_waiting_frame_test.go
@@ -1,9 +1,9 @@
-package frames
+package wire
 
 import (
 	"bytes"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/frames/stream_frame.go b/internal/wire/stream_frame.go
similarity index 98%
rename from frames/stream_frame.go
rename to internal/wire/stream_frame.go
index d16b2efdd..1da780c3d 100644
--- a/frames/stream_frame.go
+++ b/internal/wire/stream_frame.go
@@ -1,12 +1,12 @@
-package frames
+package wire
 
 import (
 	"bytes"
 	"errors"
 	"io"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
diff --git a/frames/stream_frame_test.go b/internal/wire/stream_frame_test.go
similarity index 99%
rename from frames/stream_frame_test.go
rename to internal/wire/stream_frame_test.go
index 415fee280..46b293874 100644
--- a/frames/stream_frame_test.go
+++ b/internal/wire/stream_frame_test.go
@@ -1,9 +1,9 @@
-package frames
+package wire
 
 import (
 	"bytes"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
diff --git a/internal/wire/version_negotiation.go b/internal/wire/version_negotiation.go
new file mode 100644
index 000000000..9caa7fb42
--- /dev/null
+++ b/internal/wire/version_negotiation.go
@@ -0,0 +1,26 @@
+package wire
+
+import (
+	"bytes"
+
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/utils"
+)
+
+// ComposeVersionNegotiation composes a Version Negotiation Packet
+func ComposeVersionNegotiation(connectionID protocol.ConnectionID, versions []protocol.VersionNumber) []byte {
+	fullReply := &bytes.Buffer{}
+	responsePublicHeader := PublicHeader{
+		ConnectionID: connectionID,
+		PacketNumber: 1,
+		VersionFlag:  true,
+	}
+	err := responsePublicHeader.Write(fullReply, protocol.VersionWhatever, protocol.PerspectiveServer)
+	if err != nil {
+		utils.Errorf("error composing version negotiation packet: %s", err.Error())
+	}
+	for _, v := range versions {
+		utils.LittleEndian.WriteUint32(fullReply, protocol.VersionNumberToTag(v))
+	}
+	return fullReply.Bytes()
+}
diff --git a/internal/wire/version_negotiation_test.go b/internal/wire/version_negotiation_test.go
new file mode 100644
index 000000000..39b9fb652
--- /dev/null
+++ b/internal/wire/version_negotiation_test.go
@@ -0,0 +1,17 @@
+package wire
+
+import (
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Version Negotiation Packet", func() {
+	It("composes version negotiation packets", func() {
+		expected := append(
+			[]byte{0x01 | 0x08, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
+			[]byte{'Q', '0', '9', '9'}...,
+		)
+		Expect(ComposeVersionNegotiation(1, []protocol.VersionNumber{99})).To(Equal(expected))
+	})
+})
diff --git a/frames/window_update_frame.go b/internal/wire/window_update_frame.go
similarity index 94%
rename from frames/window_update_frame.go
rename to internal/wire/window_update_frame.go
index b91aaf81f..fe896e7ab 100644
--- a/frames/window_update_frame.go
+++ b/internal/wire/window_update_frame.go
@@ -1,10 +1,10 @@
-package frames
+package wire
 
 import (
 	"bytes"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 // A WindowUpdateFrame in QUIC
diff --git a/frames/window_update_frame_test.go b/internal/wire/window_update_frame_test.go
similarity index 97%
rename from frames/window_update_frame_test.go
rename to internal/wire/window_update_frame_test.go
index 13fc7e713..a54f004db 100644
--- a/frames/window_update_frame_test.go
+++ b/internal/wire/window_update_frame_test.go
@@ -1,9 +1,9 @@
-package frames
+package wire
 
 import (
 	"bytes"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/frames/frames_suite_test.go b/internal/wire/wire_suite_test.go
similarity index 85%
rename from frames/frames_suite_test.go
rename to internal/wire/wire_suite_test.go
index f0e481ee8..322b9ede5 100644
--- a/frames/frames_suite_test.go
+++ b/internal/wire/wire_suite_test.go
@@ -1,8 +1,8 @@
-package frames
+package wire
 
 import (
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 
@@ -11,7 +11,7 @@ import (
 
 func TestCrypto(t *testing.T) {
 	RegisterFailHandler(Fail)
-	RunSpecs(t, "Frames Suite")
+	RunSpecs(t, "Wire Suite")
 }
 
 const (
diff --git a/packet_number_generator.go b/packet_number_generator.go
index 71ca9a3c4..8ece95acb 100644
--- a/packet_number_generator.go
+++ b/packet_number_generator.go
@@ -4,7 +4,7 @@ import (
 	"crypto/rand"
 	"math"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // The packetNumberGenerator generates the packet number for the next packet
diff --git a/packet_number_generator_test.go b/packet_number_generator_test.go
index f1f87fe57..1f00cb75a 100644
--- a/packet_number_generator_test.go
+++ b/packet_number_generator_test.go
@@ -3,7 +3,7 @@ package quic
 import (
 	"math"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
diff --git a/packet_packer.go b/packet_packer.go
index 28c29ace0..eeeba0a76 100644
--- a/packet_packer.go
+++ b/packet_packer.go
@@ -6,15 +6,15 @@ import (
 	"fmt"
 
 	"github.com/lucas-clemente/quic-go/ackhandler"
-	"github.com/lucas-clemente/quic-go/frames"
 	"github.com/lucas-clemente/quic-go/handshake"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 type packedPacket struct {
 	number          protocol.PacketNumber
 	raw             []byte
-	frames          []frames.Frame
+	frames          []wire.Frame
 	encryptionLevel protocol.EncryptionLevel
 }
 
@@ -28,9 +28,9 @@ type packetPacker struct {
 	connectionParameters  handshake.ConnectionParametersManager
 	streamFramer          *streamFramer
 
-	controlFrames []frames.Frame
-	stopWaiting   *frames.StopWaitingFrame
-	ackFrame      *frames.AckFrame
+	controlFrames []wire.Frame
+	stopWaiting   *wire.StopWaitingFrame
+	ackFrame      *wire.AckFrame
 	leastUnacked  protocol.PacketNumber
 }
 
@@ -53,8 +53,8 @@ func newPacketPacker(connectionID protocol.ConnectionID,
 }
 
 // PackConnectionClose packs a packet that ONLY contains a ConnectionCloseFrame
-func (p *packetPacker) PackConnectionClose(ccf *frames.ConnectionCloseFrame) (*packedPacket, error) {
-	frames := []frames.Frame{ccf}
+func (p *packetPacker) PackConnectionClose(ccf *wire.ConnectionCloseFrame) (*packedPacket, error) {
+	frames := []wire.Frame{ccf}
 	encLevel, sealer := p.cryptoSetup.GetSealer()
 	ph := p.getPublicHeader(encLevel)
 	raw, err := p.writeAndSealPacket(ph, frames, sealer)
@@ -72,7 +72,7 @@ func (p *packetPacker) PackAckPacket() (*packedPacket, error) {
 	}
 	encLevel, sealer := p.cryptoSetup.GetSealer()
 	ph := p.getPublicHeader(encLevel)
-	frames := []frames.Frame{p.ackFrame}
+	frames := []wire.Frame{p.ackFrame}
 	if p.stopWaiting != nil {
 		p.stopWaiting.PacketNumber = ph.PacketNumber
 		p.stopWaiting.PacketNumberLen = ph.PacketNumberLen
@@ -104,7 +104,7 @@ func (p *packetPacker) PackHandshakeRetransmission(packet *ackhandler.Packet) (*
 	ph := p.getPublicHeader(packet.EncryptionLevel)
 	p.stopWaiting.PacketNumber = ph.PacketNumber
 	p.stopWaiting.PacketNumberLen = ph.PacketNumberLen
-	frames := append([]frames.Frame{p.stopWaiting}, packet.Frames...)
+	frames := append([]wire.Frame{p.stopWaiting}, packet.Frames...)
 	p.stopWaiting = nil
 	raw, err := p.writeAndSealPacket(ph, frames, sealer)
 	return &packedPacket{
@@ -171,7 +171,7 @@ func (p *packetPacker) packCryptoPacket() (*packedPacket, error) {
 		return nil, err
 	}
 	maxLen := protocol.MaxFrameAndPublicHeaderSize - protocol.NonForwardSecurePacketSizeReduction - publicHeaderLength
-	frames := []frames.Frame{p.streamFramer.PopCryptoStreamFrame(maxLen)}
+	frames := []wire.Frame{p.streamFramer.PopCryptoStreamFrame(maxLen)}
 	raw, err := p.writeAndSealPacket(publicHeader, frames, sealer)
 	if err != nil {
 		return nil, err
@@ -187,9 +187,9 @@ func (p *packetPacker) packCryptoPacket() (*packedPacket, error) {
 func (p *packetPacker) composeNextPacket(
 	maxFrameSize protocol.ByteCount,
 	canSendStreamFrames bool,
-) ([]frames.Frame, error) {
+) ([]wire.Frame, error) {
 	var payloadLength protocol.ByteCount
-	var payloadFrames []frames.Frame
+	var payloadFrames []wire.Frame
 
 	// STOP_WAITING and ACK will always fit
 	if p.stopWaiting != nil {
@@ -253,21 +253,21 @@ func (p *packetPacker) composeNextPacket(
 	return payloadFrames, nil
 }
 
-func (p *packetPacker) QueueControlFrame(frame frames.Frame) {
+func (p *packetPacker) QueueControlFrame(frame wire.Frame) {
 	switch f := frame.(type) {
-	case *frames.StopWaitingFrame:
+	case *wire.StopWaitingFrame:
 		p.stopWaiting = f
-	case *frames.AckFrame:
+	case *wire.AckFrame:
 		p.ackFrame = f
 	default:
 		p.controlFrames = append(p.controlFrames, f)
 	}
 }
 
-func (p *packetPacker) getPublicHeader(encLevel protocol.EncryptionLevel) *PublicHeader {
+func (p *packetPacker) getPublicHeader(encLevel protocol.EncryptionLevel) *wire.PublicHeader {
 	pnum := p.packetNumberGenerator.Peek()
 	packetNumberLen := protocol.GetPacketNumberLengthForPublicHeader(pnum, p.leastUnacked)
-	publicHeader := &PublicHeader{
+	publicHeader := &wire.PublicHeader{
 		ConnectionID:         p.connectionID,
 		PacketNumber:         pnum,
 		PacketNumberLen:      packetNumberLen,
@@ -286,8 +286,8 @@ func (p *packetPacker) getPublicHeader(encLevel protocol.EncryptionLevel) *Publi
 }
 
 func (p *packetPacker) writeAndSealPacket(
-	publicHeader *PublicHeader,
-	payloadFrames []frames.Frame,
+	publicHeader *wire.PublicHeader,
+	payloadFrames []wire.Frame,
 	sealer handshake.Sealer,
 ) ([]byte, error) {
 	raw := getPacketBuffer()
diff --git a/packet_packer_test.go b/packet_packer_test.go
index e7e1226b4..a50f76aa0 100644
--- a/packet_packer_test.go
+++ b/packet_packer_test.go
@@ -5,10 +5,10 @@ import (
 	"math"
 
 	"github.com/lucas-clemente/quic-go/ackhandler"
-	"github.com/lucas-clemente/quic-go/frames"
 	"github.com/lucas-clemente/quic-go/handshake"
 	"github.com/lucas-clemente/quic-go/internal/mocks"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -86,7 +86,7 @@ var _ = Describe("Packet packer", func() {
 	})
 
 	It("packs single packets", func() {
-		f := &frames.StreamFrame{
+		f := &wire.StreamFrame{
 			StreamID: 5,
 			Data:     []byte{0xDE, 0xCA, 0xFB, 0xAD},
 		}
@@ -102,7 +102,7 @@ var _ = Describe("Packet packer", func() {
 
 	It("stores the encryption level a packet was sealed with", func() {
 		packer.cryptoSetup.(*mockCryptoSetup).encLevelSeal = protocol.EncryptionForwardSecure
-		f := &frames.StreamFrame{
+		f := &wire.StreamFrame{
 			StreamID: 5,
 			Data:     []byte("foobar"),
 		}
@@ -143,7 +143,7 @@ var _ = Describe("Packet packer", func() {
 	})
 
 	It("packs a ConnectionClose", func() {
-		ccf := frames.ConnectionCloseFrame{
+		ccf := wire.ConnectionCloseFrame{
 			ErrorCode:    0x1337,
 			ReasonPhrase: "foobar",
 		}
@@ -154,12 +154,12 @@ var _ = Describe("Packet packer", func() {
 	})
 
 	It("doesn't send any other frames when sending a ConnectionClose", func() {
-		ccf := frames.ConnectionCloseFrame{
+		ccf := wire.ConnectionCloseFrame{
 			ErrorCode:    0x1337,
 			ReasonPhrase: "foobar",
 		}
-		packer.controlFrames = []frames.Frame{&frames.WindowUpdateFrame{StreamID: 37}}
-		streamFramer.AddFrameForRetransmission(&frames.StreamFrame{
+		packer.controlFrames = []wire.Frame{&wire.WindowUpdateFrame{StreamID: 37}}
+		streamFramer.AddFrameForRetransmission(&wire.StreamFrame{
 			StreamID: 5,
 			Data:     []byte("foobar"),
 		})
@@ -170,8 +170,8 @@ var _ = Describe("Packet packer", func() {
 	})
 
 	It("packs only control frames", func() {
-		packer.QueueControlFrame(&frames.RstStreamFrame{})
-		packer.QueueControlFrame(&frames.WindowUpdateFrame{})
+		packer.QueueControlFrame(&wire.RstStreamFrame{})
+		packer.QueueControlFrame(&wire.WindowUpdateFrame{})
 		p, err := packer.PackPacket()
 		Expect(p).ToNot(BeNil())
 		Expect(err).ToNot(HaveOccurred())
@@ -180,11 +180,11 @@ var _ = Describe("Packet packer", func() {
 	})
 
 	It("increases the packet number", func() {
-		packer.QueueControlFrame(&frames.RstStreamFrame{})
+		packer.QueueControlFrame(&wire.RstStreamFrame{})
 		p1, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p1).ToNot(BeNil())
-		packer.QueueControlFrame(&frames.RstStreamFrame{})
+		packer.QueueControlFrame(&wire.RstStreamFrame{})
 		p2, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p2).ToNot(BeNil())
@@ -193,8 +193,8 @@ var _ = Describe("Packet packer", func() {
 
 	It("packs a StopWaitingFrame first", func() {
 		packer.packetNumberGenerator.next = 15
-		swf := &frames.StopWaitingFrame{LeastUnacked: 10}
-		packer.QueueControlFrame(&frames.RstStreamFrame{})
+		swf := &wire.StopWaitingFrame{LeastUnacked: 10}
+		packer.QueueControlFrame(&wire.RstStreamFrame{})
 		packer.QueueControlFrame(swf)
 		p, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
@@ -206,16 +206,16 @@ var _ = Describe("Packet packer", func() {
 	It("sets the LeastUnackedDelta length of a StopWaitingFrame", func() {
 		packetNumber := protocol.PacketNumber(0xDECAFB) // will result in a 4 byte packet number
 		packer.packetNumberGenerator.next = packetNumber
-		swf := &frames.StopWaitingFrame{LeastUnacked: packetNumber - 0x100}
-		packer.QueueControlFrame(&frames.RstStreamFrame{})
+		swf := &wire.StopWaitingFrame{LeastUnacked: packetNumber - 0x100}
+		packer.QueueControlFrame(&wire.RstStreamFrame{})
 		packer.QueueControlFrame(swf)
 		p, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
-		Expect(p.frames[0].(*frames.StopWaitingFrame).PacketNumberLen).To(Equal(protocol.PacketNumberLen4))
+		Expect(p.frames[0].(*wire.StopWaitingFrame).PacketNumberLen).To(Equal(protocol.PacketNumberLen4))
 	})
 
 	It("does not pack a packet containing only a StopWaitingFrame", func() {
-		swf := &frames.StopWaitingFrame{LeastUnacked: 10}
+		swf := &wire.StopWaitingFrame{LeastUnacked: 10}
 		packer.QueueControlFrame(swf)
 		p, err := packer.PackPacket()
 		Expect(p).To(BeNil())
@@ -223,7 +223,7 @@ var _ = Describe("Packet packer", func() {
 	})
 
 	It("packs a packet if it has queued control frames, but no new control frames", func() {
-		packer.controlFrames = []frames.Frame{&frames.BlockedFrame{StreamID: 0}}
+		packer.controlFrames = []wire.Frame{&wire.BlockedFrame{StreamID: 0}}
 		p, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p).ToNot(BeNil())
@@ -232,13 +232,13 @@ var _ = Describe("Packet packer", func() {
 	It("adds the version flag to the public header before the crypto handshake is finished", func() {
 		packer.perspective = protocol.PerspectiveClient
 		packer.cryptoSetup.(*mockCryptoSetup).encLevelSeal = protocol.EncryptionSecure
-		packer.controlFrames = []frames.Frame{&frames.BlockedFrame{StreamID: 0}}
+		packer.controlFrames = []wire.Frame{&wire.BlockedFrame{StreamID: 0}}
 		packer.connectionID = 0x1337
 		packer.version = 123
 		p, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p).ToNot(BeNil())
-		hdr, err := ParsePublicHeader(bytes.NewReader(p.raw), protocol.PerspectiveClient, packer.version)
+		hdr, err := wire.ParsePublicHeader(bytes.NewReader(p.raw), protocol.PerspectiveClient, packer.version)
 		Expect(err).ToNot(HaveOccurred())
 		Expect(hdr.VersionFlag).To(BeTrue())
 		Expect(hdr.VersionNumber).To(Equal(packer.version))
@@ -247,22 +247,22 @@ var _ = Describe("Packet packer", func() {
 	It("doesn't add the version flag to the public header for forward-secure packets", func() {
 		packer.perspective = protocol.PerspectiveClient
 		packer.cryptoSetup.(*mockCryptoSetup).encLevelSeal = protocol.EncryptionForwardSecure
-		packer.controlFrames = []frames.Frame{&frames.BlockedFrame{StreamID: 0}}
+		packer.controlFrames = []wire.Frame{&wire.BlockedFrame{StreamID: 0}}
 		packer.connectionID = 0x1337
 		p, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p).ToNot(BeNil())
-		hdr, err := ParsePublicHeader(bytes.NewReader(p.raw), protocol.PerspectiveClient, packer.version)
+		hdr, err := wire.ParsePublicHeader(bytes.NewReader(p.raw), protocol.PerspectiveClient, packer.version)
 		Expect(err).ToNot(HaveOccurred())
 		Expect(hdr.VersionFlag).To(BeFalse())
 	})
 
 	It("packs many control frames into 1 packets", func() {
-		f := &frames.AckFrame{LargestAcked: 1}
+		f := &wire.AckFrame{LargestAcked: 1}
 		b := &bytes.Buffer{}
 		f.Write(b, protocol.VersionWhatever)
 		maxFramesPerPacket := int(protocol.MaxFrameAndPublicHeaderSize-publicHeaderLen) / b.Len()
-		var controlFrames []frames.Frame
+		var controlFrames []wire.Frame
 		for i := 0; i < maxFramesPerPacket; i++ {
 			controlFrames = append(controlFrames, f)
 		}
@@ -276,12 +276,12 @@ var _ = Describe("Packet packer", func() {
 	})
 
 	It("packs a lot of control frames into 2 packets if they don't fit into one", func() {
-		blockedFrame := &frames.BlockedFrame{
+		blockedFrame := &wire.BlockedFrame{
 			StreamID: 0x1337,
 		}
 		minLength, _ := blockedFrame.MinLength(0)
 		maxFramesPerPacket := int(protocol.MaxFrameAndPublicHeaderSize-publicHeaderLen) / int(minLength)
-		var controlFrames []frames.Frame
+		var controlFrames []wire.Frame
 		for i := 0; i < maxFramesPerPacket+10; i++ {
 			controlFrames = append(controlFrames, blockedFrame)
 		}
@@ -300,7 +300,7 @@ var _ = Describe("Packet packer", func() {
 		Expect(p).To(BeNil())
 		Expect(err).ToNot(HaveOccurred())
 		Expect(packer.packetNumberGenerator.Peek()).To(Equal(protocol.PacketNumber(1)))
-		f := &frames.StreamFrame{
+		f := &wire.StreamFrame{
 			StreamID: 5,
 			Data:     []byte{0xDE, 0xCA, 0xFB, 0xAD},
 		}
@@ -314,7 +314,7 @@ var _ = Describe("Packet packer", func() {
 
 	Context("Stream Frame handling", func() {
 		It("does not splits a stream frame with maximum size", func() {
-			f := &frames.StreamFrame{
+			f := &wire.StreamFrame{
 				Offset:         1,
 				StreamID:       5,
 				DataLenPresent: false,
@@ -326,7 +326,7 @@ var _ = Describe("Packet packer", func() {
 			payloadFrames, err := packer.composeNextPacket(maxFrameSize, true)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(payloadFrames).To(HaveLen(1))
-			Expect(payloadFrames[0].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
+			Expect(payloadFrames[0].(*wire.StreamFrame).DataLenPresent).To(BeFalse())
 			payloadFrames, err = packer.composeNextPacket(maxFrameSize, true)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(payloadFrames).To(BeEmpty())
@@ -334,12 +334,12 @@ var _ = Describe("Packet packer", func() {
 
 		It("correctly handles a stream frame with one byte less than maximum size", func() {
 			maxStreamFrameDataLen := protocol.MaxFrameAndPublicHeaderSize - publicHeaderLen - (1 + 1 + 2) - 1
-			f1 := &frames.StreamFrame{
+			f1 := &wire.StreamFrame{
 				StreamID: 5,
 				Offset:   1,
 				Data:     bytes.Repeat([]byte{'f'}, int(maxStreamFrameDataLen)),
 			}
-			f2 := &frames.StreamFrame{
+			f2 := &wire.StreamFrame{
 				StreamID: 5,
 				Offset:   1,
 				Data:     []byte("foobar"),
@@ -350,23 +350,23 @@ var _ = Describe("Packet packer", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.raw).To(HaveLen(int(protocol.MaxPacketSize - 1)))
 			Expect(p.frames).To(HaveLen(1))
-			Expect(p.frames[0].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
+			Expect(p.frames[0].(*wire.StreamFrame).DataLenPresent).To(BeFalse())
 			p, err = packer.PackPacket()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.frames).To(HaveLen(1))
-			Expect(p.frames[0].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
+			Expect(p.frames[0].(*wire.StreamFrame).DataLenPresent).To(BeFalse())
 		})
 
 		It("packs multiple small stream frames into single packet", func() {
-			f1 := &frames.StreamFrame{
+			f1 := &wire.StreamFrame{
 				StreamID: 5,
 				Data:     []byte{0xDE, 0xCA, 0xFB, 0xAD},
 			}
-			f2 := &frames.StreamFrame{
+			f2 := &wire.StreamFrame{
 				StreamID: 5,
 				Data:     []byte{0xBE, 0xEF, 0x13, 0x37},
 			}
-			f3 := &frames.StreamFrame{
+			f3 := &wire.StreamFrame{
 				StreamID: 3,
 				Data:     []byte{0xCA, 0xFE},
 			}
@@ -381,16 +381,16 @@ var _ = Describe("Packet packer", func() {
 			f2.Write(b, 0)
 			f3.Write(b, 0)
 			Expect(p.frames).To(HaveLen(3))
-			Expect(p.frames[0].(*frames.StreamFrame).DataLenPresent).To(BeTrue())
-			Expect(p.frames[1].(*frames.StreamFrame).DataLenPresent).To(BeTrue())
-			Expect(p.frames[2].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
+			Expect(p.frames[0].(*wire.StreamFrame).DataLenPresent).To(BeTrue())
+			Expect(p.frames[1].(*wire.StreamFrame).DataLenPresent).To(BeTrue())
+			Expect(p.frames[2].(*wire.StreamFrame).DataLenPresent).To(BeFalse())
 			Expect(p.raw).To(ContainSubstring(string(f1.Data)))
 			Expect(p.raw).To(ContainSubstring(string(f2.Data)))
 			Expect(p.raw).To(ContainSubstring(string(f3.Data)))
 		})
 
 		It("splits one stream frame larger than maximum size", func() {
-			f := &frames.StreamFrame{
+			f := &wire.StreamFrame{
 				StreamID: 7,
 				Offset:   1,
 			}
@@ -401,13 +401,13 @@ var _ = Describe("Packet packer", func() {
 			payloadFrames, err := packer.composeNextPacket(maxFrameSize, true)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(payloadFrames).To(HaveLen(1))
-			Expect(payloadFrames[0].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
-			Expect(payloadFrames[0].(*frames.StreamFrame).Data).To(HaveLen(int(maxStreamFrameDataLen)))
+			Expect(payloadFrames[0].(*wire.StreamFrame).DataLenPresent).To(BeFalse())
+			Expect(payloadFrames[0].(*wire.StreamFrame).Data).To(HaveLen(int(maxStreamFrameDataLen)))
 			payloadFrames, err = packer.composeNextPacket(maxFrameSize, true)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(payloadFrames).To(HaveLen(1))
-			Expect(payloadFrames[0].(*frames.StreamFrame).Data).To(HaveLen(200))
-			Expect(payloadFrames[0].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
+			Expect(payloadFrames[0].(*wire.StreamFrame).Data).To(HaveLen(200))
+			Expect(payloadFrames[0].(*wire.StreamFrame).DataLenPresent).To(BeFalse())
 			payloadFrames, err = packer.composeNextPacket(maxFrameSize, true)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(payloadFrames).To(BeEmpty())
@@ -415,12 +415,12 @@ var _ = Describe("Packet packer", func() {
 
 		It("packs 2 stream frames that are too big for one packet correctly", func() {
 			maxStreamFrameDataLen := protocol.MaxFrameAndPublicHeaderSize - publicHeaderLen - (1 + 1 + 2)
-			f1 := &frames.StreamFrame{
+			f1 := &wire.StreamFrame{
 				StreamID: 5,
 				Data:     bytes.Repeat([]byte{'f'}, int(maxStreamFrameDataLen)+100),
 				Offset:   1,
 			}
-			f2 := &frames.StreamFrame{
+			f2 := &wire.StreamFrame{
 				StreamID: 5,
 				Data:     bytes.Repeat([]byte{'f'}, int(maxStreamFrameDataLen)+100),
 				Offset:   1,
@@ -430,17 +430,17 @@ var _ = Describe("Packet packer", func() {
 			p, err := packer.PackPacket()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.frames).To(HaveLen(1))
-			Expect(p.frames[0].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
+			Expect(p.frames[0].(*wire.StreamFrame).DataLenPresent).To(BeFalse())
 			Expect(p.raw).To(HaveLen(int(protocol.MaxPacketSize)))
 			p, err = packer.PackPacket()
 			Expect(p.frames).To(HaveLen(2))
-			Expect(p.frames[0].(*frames.StreamFrame).DataLenPresent).To(BeTrue())
-			Expect(p.frames[1].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
+			Expect(p.frames[0].(*wire.StreamFrame).DataLenPresent).To(BeTrue())
+			Expect(p.frames[1].(*wire.StreamFrame).DataLenPresent).To(BeFalse())
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.raw).To(HaveLen(int(protocol.MaxPacketSize)))
 			p, err = packer.PackPacket()
 			Expect(p.frames).To(HaveLen(1))
-			Expect(p.frames[0].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
+			Expect(p.frames[0].(*wire.StreamFrame).DataLenPresent).To(BeFalse())
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p).ToNot(BeNil())
 			p, err = packer.PackPacket()
@@ -449,7 +449,7 @@ var _ = Describe("Packet packer", func() {
 		})
 
 		It("packs a packet that has the maximum packet size when given a large enough stream frame", func() {
-			f := &frames.StreamFrame{
+			f := &wire.StreamFrame{
 				StreamID: 5,
 				Offset:   1,
 			}
@@ -463,7 +463,7 @@ var _ = Describe("Packet packer", func() {
 		})
 
 		It("splits a stream frame larger than the maximum size", func() {
-			f := &frames.StreamFrame{
+			f := &wire.StreamFrame{
 				StreamID: 5,
 				Offset:   1,
 			}
@@ -481,7 +481,7 @@ var _ = Describe("Packet packer", func() {
 
 		It("refuses to send unencrypted stream data on a data stream", func() {
 			packer.cryptoSetup.(*mockCryptoSetup).encLevelSeal = protocol.EncryptionUnencrypted
-			f := &frames.StreamFrame{
+			f := &wire.StreamFrame{
 				StreamID: 3,
 				Data:     []byte("foobar"),
 			}
@@ -494,7 +494,7 @@ var _ = Describe("Packet packer", func() {
 		It("sends non forward-secure data as the client", func() {
 			packer.perspective = protocol.PerspectiveClient
 			packer.cryptoSetup.(*mockCryptoSetup).encLevelSeal = protocol.EncryptionSecure
-			f := &frames.StreamFrame{
+			f := &wire.StreamFrame{
 				StreamID: 5,
 				Data:     []byte("foobar"),
 			}
@@ -507,7 +507,7 @@ var _ = Describe("Packet packer", func() {
 
 		It("does not send non forward-secure data as the server", func() {
 			packer.cryptoSetup.(*mockCryptoSetup).encLevelSeal = protocol.EncryptionSecure
-			f := &frames.StreamFrame{
+			f := &wire.StreamFrame{
 				StreamID: 5,
 				Data:     []byte("foobar"),
 			}
@@ -524,7 +524,7 @@ var _ = Describe("Packet packer", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.encryptionLevel).To(Equal(protocol.EncryptionUnencrypted))
 			Expect(p.frames).To(HaveLen(1))
-			Expect(p.frames[0]).To(Equal(&frames.StreamFrame{StreamID: 1, Data: []byte("foobar")}))
+			Expect(p.frames[0]).To(Equal(&wire.StreamFrame{StreamID: 1, Data: []byte("foobar")}))
 		})
 
 		It("sends encrypted stream data on the crypto stream", func() {
@@ -534,38 +534,38 @@ var _ = Describe("Packet packer", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.encryptionLevel).To(Equal(protocol.EncryptionSecure))
 			Expect(p.frames).To(HaveLen(1))
-			Expect(p.frames[0]).To(Equal(&frames.StreamFrame{StreamID: 1, Data: []byte("foobar")}))
+			Expect(p.frames[0]).To(Equal(&wire.StreamFrame{StreamID: 1, Data: []byte("foobar")}))
 		})
 
 		It("does not pack stream frames if not allowed", func() {
 			packer.cryptoSetup.(*mockCryptoSetup).encLevelSeal = protocol.EncryptionUnencrypted
-			packer.QueueControlFrame(&frames.AckFrame{})
-			streamFramer.AddFrameForRetransmission(&frames.StreamFrame{StreamID: 3, Data: []byte("foobar")})
+			packer.QueueControlFrame(&wire.AckFrame{})
+			streamFramer.AddFrameForRetransmission(&wire.StreamFrame{StreamID: 3, Data: []byte("foobar")})
 			p, err := packer.PackPacket()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.frames).To(HaveLen(1))
-			Expect(func() { _ = p.frames[0].(*frames.AckFrame) }).NotTo(Panic())
+			Expect(func() { _ = p.frames[0].(*wire.AckFrame) }).NotTo(Panic())
 		})
 	})
 
 	Context("Blocked frames", func() {
 		It("queues a BLOCKED frame", func() {
 			length := 100
-			streamFramer.blockedFrameQueue = []*frames.BlockedFrame{{StreamID: 5}}
-			f := &frames.StreamFrame{
+			streamFramer.blockedFrameQueue = []*wire.BlockedFrame{{StreamID: 5}}
+			f := &wire.StreamFrame{
 				StreamID: 5,
 				Data:     bytes.Repeat([]byte{'f'}, length),
 			}
 			streamFramer.AddFrameForRetransmission(f)
 			_, err := packer.composeNextPacket(maxFrameSize, true)
 			Expect(err).ToNot(HaveOccurred())
-			Expect(packer.controlFrames[0]).To(Equal(&frames.BlockedFrame{StreamID: 5}))
+			Expect(packer.controlFrames[0]).To(Equal(&wire.BlockedFrame{StreamID: 5}))
 		})
 
 		It("removes the dataLen attribute from the last StreamFrame, even if it queued a BLOCKED frame", func() {
 			length := 100
-			streamFramer.blockedFrameQueue = []*frames.BlockedFrame{{StreamID: 5}}
-			f := &frames.StreamFrame{
+			streamFramer.blockedFrameQueue = []*wire.BlockedFrame{{StreamID: 5}}
+			f := &wire.StreamFrame{
 				StreamID: 5,
 				Data:     bytes.Repeat([]byte{'f'}, length),
 			}
@@ -573,31 +573,31 @@ var _ = Describe("Packet packer", func() {
 			p, err := packer.composeNextPacket(maxFrameSize, true)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p).To(HaveLen(1))
-			Expect(p[0].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
+			Expect(p[0].(*wire.StreamFrame).DataLenPresent).To(BeFalse())
 		})
 
 		It("packs a connection-level BlockedFrame", func() {
-			streamFramer.blockedFrameQueue = []*frames.BlockedFrame{{StreamID: 0}}
-			f := &frames.StreamFrame{
+			streamFramer.blockedFrameQueue = []*wire.BlockedFrame{{StreamID: 0}}
+			f := &wire.StreamFrame{
 				StreamID: 5,
 				Data:     []byte("foobar"),
 			}
 			streamFramer.AddFrameForRetransmission(f)
 			_, err := packer.composeNextPacket(maxFrameSize, true)
 			Expect(err).ToNot(HaveOccurred())
-			Expect(packer.controlFrames[0]).To(Equal(&frames.BlockedFrame{StreamID: 0}))
+			Expect(packer.controlFrames[0]).To(Equal(&wire.BlockedFrame{StreamID: 0}))
 		})
 	})
 
 	It("returns nil if we only have a single STOP_WAITING", func() {
-		packer.QueueControlFrame(&frames.StopWaitingFrame{})
+		packer.QueueControlFrame(&wire.StopWaitingFrame{})
 		p, err := packer.PackPacket()
 		Expect(err).NotTo(HaveOccurred())
 		Expect(p).To(BeNil())
 	})
 
 	It("packs a single ACK", func() {
-		ack := &frames.AckFrame{LargestAcked: 42}
+		ack := &wire.AckFrame{LargestAcked: 42}
 		packer.QueueControlFrame(ack)
 		p, err := packer.PackPacket()
 		Expect(err).NotTo(HaveOccurred())
@@ -606,7 +606,7 @@ var _ = Describe("Packet packer", func() {
 	})
 
 	It("does not return nil if we only have a single ACK but request it to be sent", func() {
-		ack := &frames.AckFrame{}
+		ack := &wire.AckFrame{}
 		packer.QueueControlFrame(ack)
 		p, err := packer.PackPacket()
 		Expect(err).NotTo(HaveOccurred())
@@ -614,7 +614,7 @@ var _ = Describe("Packet packer", func() {
 	})
 
 	It("queues a control frame to be sent in the next packet", func() {
-		wuf := &frames.WindowUpdateFrame{StreamID: 5}
+		wuf := &wire.WindowUpdateFrame{StreamID: 5}
 		packer.QueueControlFrame(wuf)
 		p, err := packer.PackPacket()
 		Expect(err).NotTo(HaveOccurred())
@@ -623,8 +623,8 @@ var _ = Describe("Packet packer", func() {
 	})
 
 	Context("retransmitting of handshake packets", func() {
-		swf := &frames.StopWaitingFrame{LeastUnacked: 1}
-		sf := &frames.StreamFrame{
+		swf := &wire.StopWaitingFrame{LeastUnacked: 1}
+		sf := &wire.StreamFrame{
 			StreamID: 1,
 			Data:     []byte("foobar"),
 		}
@@ -636,7 +636,7 @@ var _ = Describe("Packet packer", func() {
 		It("packs a retransmission for a packet sent with no encryption", func() {
 			packet := &ackhandler.Packet{
 				EncryptionLevel: protocol.EncryptionUnencrypted,
-				Frames:          []frames.Frame{sf},
+				Frames:          []wire.Frame{sf},
 			}
 			p, err := packer.PackHandshakeRetransmission(packet)
 			Expect(err).ToNot(HaveOccurred())
@@ -650,7 +650,7 @@ var _ = Describe("Packet packer", func() {
 			packer.cryptoSetup.(*mockCryptoSetup).divNonce = nonce
 			packet := &ackhandler.Packet{
 				EncryptionLevel: protocol.EncryptionSecure,
-				Frames:          []frames.Frame{sf},
+				Frames:          []wire.Frame{sf},
 			}
 			p, err := packer.PackHandshakeRetransmission(packet)
 			Expect(err).ToNot(HaveOccurred())
@@ -665,7 +665,7 @@ var _ = Describe("Packet packer", func() {
 		It("includes the diversification nonce on packets sent with initial encryption", func() {
 			packet := &ackhandler.Packet{
 				EncryptionLevel: protocol.EncryptionSecure,
-				Frames:          []frames.Frame{sf},
+				Frames:          []wire.Frame{sf},
 			}
 			p, err := packer.PackHandshakeRetransmission(packet)
 			Expect(err).ToNot(HaveOccurred())
@@ -677,8 +677,8 @@ var _ = Describe("Packet packer", func() {
 		It("refuses to send a packet larger than MaxPacketSize", func() {
 			packet := &ackhandler.Packet{
 				EncryptionLevel: protocol.EncryptionSecure,
-				Frames: []frames.Frame{
-					&frames.StreamFrame{
+				Frames: []wire.Frame{
+					&wire.StreamFrame{
 						StreamID: 1,
 						Data:     bytes.Repeat([]byte{'f'}, int(protocol.MaxPacketSize-5)),
 					},
@@ -707,20 +707,20 @@ var _ = Describe("Packet packer", func() {
 
 	Context("packing ACK packets", func() {
 		It("packs ACK packets", func() {
-			packer.QueueControlFrame(&frames.AckFrame{})
+			packer.QueueControlFrame(&wire.AckFrame{})
 			p, err := packer.PackAckPacket()
 			Expect(err).NotTo(HaveOccurred())
-			Expect(p.frames).To(Equal([]frames.Frame{&frames.AckFrame{DelayTime: math.MaxInt64}}))
+			Expect(p.frames).To(Equal([]wire.Frame{&wire.AckFrame{DelayTime: math.MaxInt64}}))
 		})
 
 		It("packs ACK packets with SWFs", func() {
-			packer.QueueControlFrame(&frames.AckFrame{})
-			packer.QueueControlFrame(&frames.StopWaitingFrame{})
+			packer.QueueControlFrame(&wire.AckFrame{})
+			packer.QueueControlFrame(&wire.StopWaitingFrame{})
 			p, err := packer.PackAckPacket()
 			Expect(err).NotTo(HaveOccurred())
-			Expect(p.frames).To(Equal([]frames.Frame{
-				&frames.AckFrame{DelayTime: math.MaxInt64},
-				&frames.StopWaitingFrame{PacketNumber: 1, PacketNumberLen: 2},
+			Expect(p.frames).To(Equal([]wire.Frame{
+				&wire.AckFrame{DelayTime: math.MaxInt64},
+				&wire.StopWaitingFrame{PacketNumber: 1, PacketNumberLen: 2},
 			}))
 		})
 	})
diff --git a/packet_unpacker.go b/packet_unpacker.go
index 19499e6ee..055f67544 100644
--- a/packet_unpacker.go
+++ b/packet_unpacker.go
@@ -5,14 +5,14 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
 type unpackedPacket struct {
 	encryptionLevel protocol.EncryptionLevel
-	frames          []frames.Frame
+	frames          []wire.Frame
 }
 
 type quicAEAD interface {
@@ -24,7 +24,7 @@ type packetUnpacker struct {
 	aead    quicAEAD
 }
 
-func (u *packetUnpacker) Unpack(publicHeaderBinary []byte, hdr *PublicHeader, data []byte) (*unpackedPacket, error) {
+func (u *packetUnpacker) Unpack(publicHeaderBinary []byte, hdr *wire.PublicHeader, data []byte) (*unpackedPacket, error) {
 	buf := getPacketBuffer()
 	defer putPacketBuffer(buf)
 	decrypted, encryptionLevel, err := u.aead.Open(buf, data, hdr.PacketNumber, publicHeaderBinary)
@@ -38,7 +38,7 @@ func (u *packetUnpacker) Unpack(publicHeaderBinary []byte, hdr *PublicHeader, da
 		return nil, qerr.MissingPayload
 	}
 
-	fs := make([]frames.Frame, 0, 2)
+	fs := make([]wire.Frame, 0, 2)
 
 	// Read all frames in the packet
 	for r.Len() > 0 {
@@ -48,19 +48,19 @@ func (u *packetUnpacker) Unpack(publicHeaderBinary []byte, hdr *PublicHeader, da
 		}
 		r.UnreadByte()
 
-		var frame frames.Frame
+		var frame wire.Frame
 		if typeByte&0x80 == 0x80 {
-			frame, err = frames.ParseStreamFrame(r, u.version)
+			frame, err = wire.ParseStreamFrame(r, u.version)
 			if err != nil {
 				err = qerr.Error(qerr.InvalidStreamData, err.Error())
 			} else {
-				streamID := frame.(*frames.StreamFrame).StreamID
+				streamID := frame.(*wire.StreamFrame).StreamID
 				if streamID != 1 && encryptionLevel <= protocol.EncryptionUnencrypted {
 					err = qerr.Error(qerr.UnencryptedStreamData, fmt.Sprintf("received unencrypted stream data on stream %d", streamID))
 				}
 			}
 		} else if typeByte&0xc0 == 0x40 {
-			frame, err = frames.ParseAckFrame(r, u.version)
+			frame, err = wire.ParseAckFrame(r, u.version)
 			if err != nil {
 				err = qerr.Error(qerr.InvalidAckData, err.Error())
 			}
@@ -69,37 +69,37 @@ func (u *packetUnpacker) Unpack(publicHeaderBinary []byte, hdr *PublicHeader, da
 		} else {
 			switch typeByte {
 			case 0x01:
-				frame, err = frames.ParseRstStreamFrame(r, u.version)
+				frame, err = wire.ParseRstStreamFrame(r, u.version)
 				if err != nil {
 					err = qerr.Error(qerr.InvalidRstStreamData, err.Error())
 				}
 			case 0x02:
-				frame, err = frames.ParseConnectionCloseFrame(r, u.version)
+				frame, err = wire.ParseConnectionCloseFrame(r, u.version)
 				if err != nil {
 					err = qerr.Error(qerr.InvalidConnectionCloseData, err.Error())
 				}
 			case 0x03:
-				frame, err = frames.ParseGoawayFrame(r, u.version)
+				frame, err = wire.ParseGoawayFrame(r, u.version)
 				if err != nil {
 					err = qerr.Error(qerr.InvalidGoawayData, err.Error())
 				}
 			case 0x04:
-				frame, err = frames.ParseWindowUpdateFrame(r, u.version)
+				frame, err = wire.ParseWindowUpdateFrame(r, u.version)
 				if err != nil {
 					err = qerr.Error(qerr.InvalidWindowUpdateData, err.Error())
 				}
 			case 0x05:
-				frame, err = frames.ParseBlockedFrame(r, u.version)
+				frame, err = wire.ParseBlockedFrame(r, u.version)
 				if err != nil {
 					err = qerr.Error(qerr.InvalidBlockedData, err.Error())
 				}
 			case 0x06:
-				frame, err = frames.ParseStopWaitingFrame(r, hdr.PacketNumber, hdr.PacketNumberLen, u.version)
+				frame, err = wire.ParseStopWaitingFrame(r, hdr.PacketNumber, hdr.PacketNumberLen, u.version)
 				if err != nil {
 					err = qerr.Error(qerr.InvalidStopWaitingData, err.Error())
 				}
 			case 0x07:
-				frame, err = frames.ParsePingFrame(r, u.version)
+				frame, err = wire.ParsePingFrame(r, u.version)
 			default:
 				err = qerr.Error(qerr.InvalidFrameData, fmt.Sprintf("unknown type byte 0x%x", typeByte))
 			}
diff --git a/packet_unpacker_test.go b/packet_unpacker_test.go
index b56ba2f41..418ab9225 100644
--- a/packet_unpacker_test.go
+++ b/packet_unpacker_test.go
@@ -4,8 +4,8 @@ import (
 	"bytes"
 
 	"github.com/lucas-clemente/quic-go/crypto"
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	"github.com/lucas-clemente/quic-go/qerr"
 
 	. "github.com/onsi/ginkgo"
@@ -31,14 +31,14 @@ var _ quicAEAD = &mockAEAD{}
 var _ = Describe("Packet unpacker", func() {
 	var (
 		unpacker *packetUnpacker
-		hdr      *PublicHeader
+		hdr      *wire.PublicHeader
 		hdrBin   []byte
 		data     []byte
 		buf      *bytes.Buffer
 	)
 
 	BeforeEach(func() {
-		hdr = &PublicHeader{
+		hdr = &wire.PublicHeader{
 			PacketNumber:    10,
 			PacketNumberLen: 1,
 		}
@@ -53,17 +53,17 @@ var _ = Describe("Packet unpacker", func() {
 	}
 
 	It("does not read read a private flag for QUIC Version >= 34", func() {
-		f := &frames.ConnectionCloseFrame{ReasonPhrase: "foo"}
+		f := &wire.ConnectionCloseFrame{ReasonPhrase: "foo"}
 		err := f.Write(buf, 0)
 		Expect(err).ToNot(HaveOccurred())
 		setData(buf.Bytes())
 		packet, err := unpacker.Unpack(hdrBin, hdr, data)
 		Expect(err).ToNot(HaveOccurred())
-		Expect(packet.frames).To(Equal([]frames.Frame{f}))
+		Expect(packet.frames).To(Equal([]wire.Frame{f}))
 	})
 
 	It("saves the encryption level", func() {
-		f := &frames.ConnectionCloseFrame{ReasonPhrase: "foo"}
+		f := &wire.ConnectionCloseFrame{ReasonPhrase: "foo"}
 		err := f.Write(buf, 0)
 		Expect(err).ToNot(HaveOccurred())
 		setData(buf.Bytes())
@@ -75,7 +75,7 @@ var _ = Describe("Packet unpacker", func() {
 
 	It("unpacks ACK frames", func() {
 		unpacker.version = protocol.VersionWhatever
-		f := &frames.AckFrame{
+		f := &wire.AckFrame{
 			LargestAcked: 0x13,
 			LowestAcked:  1,
 		}
@@ -85,7 +85,7 @@ var _ = Describe("Packet unpacker", func() {
 		packet, err := unpacker.Unpack(hdrBin, hdr, data)
 		Expect(err).ToNot(HaveOccurred())
 		Expect(packet.frames).To(HaveLen(1))
-		readFrame := packet.frames[0].(*frames.AckFrame)
+		readFrame := packet.frames[0].(*wire.AckFrame)
 		Expect(readFrame).ToNot(BeNil())
 		Expect(readFrame.LargestAcked).To(Equal(protocol.PacketNumber(0x13)))
 	})
@@ -104,7 +104,7 @@ var _ = Describe("Packet unpacker", func() {
 	})
 
 	It("handles PADDING between two other frames", func() {
-		f := &frames.PingFrame{}
+		f := &wire.PingFrame{}
 		err := f.Write(buf, protocol.VersionWhatever)
 		Expect(err).ToNot(HaveOccurred())
 		_, err = buf.Write(bytes.Repeat([]byte{0}, 10)) // 10 bytes PADDING
@@ -121,8 +121,8 @@ var _ = Describe("Packet unpacker", func() {
 		setData([]byte{0x01, 0xEF, 0xBE, 0xAD, 0xDE, 0x44, 0x33, 0x22, 0x11, 0xAD, 0xFB, 0xCA, 0xDE, 0x34, 0x12, 0x37, 0x13})
 		packet, err := unpacker.Unpack(hdrBin, hdr, data)
 		Expect(err).ToNot(HaveOccurred())
-		Expect(packet.frames).To(Equal([]frames.Frame{
-			&frames.RstStreamFrame{
+		Expect(packet.frames).To(Equal([]wire.Frame{
+			&wire.RstStreamFrame{
 				StreamID:   0xDEADBEEF,
 				ByteOffset: 0xDECAFBAD11223344,
 				ErrorCode:  0x13371234,
@@ -131,13 +131,13 @@ var _ = Describe("Packet unpacker", func() {
 	})
 
 	It("unpacks CONNECTION_CLOSE frames", func() {
-		f := &frames.ConnectionCloseFrame{ReasonPhrase: "foo"}
+		f := &wire.ConnectionCloseFrame{ReasonPhrase: "foo"}
 		err := f.Write(buf, 0)
 		Expect(err).ToNot(HaveOccurred())
 		setData(buf.Bytes())
 		packet, err := unpacker.Unpack(hdrBin, hdr, data)
 		Expect(err).ToNot(HaveOccurred())
-		Expect(packet.frames).To(Equal([]frames.Frame{f}))
+		Expect(packet.frames).To(Equal([]wire.Frame{f}))
 	})
 
 	It("accepts GOAWAY frames", func() {
@@ -150,8 +150,8 @@ var _ = Describe("Packet unpacker", func() {
 		})
 		packet, err := unpacker.Unpack(hdrBin, hdr, data)
 		Expect(err).ToNot(HaveOccurred())
-		Expect(packet.frames).To(Equal([]frames.Frame{
-			&frames.GoawayFrame{
+		Expect(packet.frames).To(Equal([]wire.Frame{
+			&wire.GoawayFrame{
 				ErrorCode:      1,
 				LastGoodStream: 2,
 				ReasonPhrase:   "foo",
@@ -163,8 +163,8 @@ var _ = Describe("Packet unpacker", func() {
 		setData([]byte{0x04, 0xEF, 0xBE, 0xAD, 0xDE, 0x37, 0x13, 0, 0, 0, 0, 0xFE, 0xCA})
 		packet, err := unpacker.Unpack(hdrBin, hdr, data)
 		Expect(err).ToNot(HaveOccurred())
-		Expect(packet.frames).To(Equal([]frames.Frame{
-			&frames.WindowUpdateFrame{
+		Expect(packet.frames).To(Equal([]wire.Frame{
+			&wire.WindowUpdateFrame{
 				StreamID:   0xDEADBEEF,
 				ByteOffset: 0xCAFE000000001337,
 			},
@@ -175,10 +175,8 @@ var _ = Describe("Packet unpacker", func() {
 		setData([]byte{0x05, 0xEF, 0xBE, 0xAD, 0xDE})
 		packet, err := unpacker.Unpack(hdrBin, hdr, data)
 		Expect(err).ToNot(HaveOccurred())
-		Expect(packet.frames).To(Equal([]frames.Frame{
-			&frames.BlockedFrame{
-				StreamID: 0xDEADBEEF,
-			},
+		Expect(packet.frames).To(Equal([]wire.Frame{
+			&wire.BlockedFrame{StreamID: 0xDEADBEEF},
 		}))
 	})
 
@@ -186,10 +184,8 @@ var _ = Describe("Packet unpacker", func() {
 		setData([]byte{0x06, 0x03})
 		packet, err := unpacker.Unpack(hdrBin, hdr, data)
 		Expect(err).ToNot(HaveOccurred())
-		Expect(packet.frames).To(Equal([]frames.Frame{
-			&frames.StopWaitingFrame{
-				LeastUnacked: 7,
-			},
+		Expect(packet.frames).To(Equal([]wire.Frame{
+			&wire.StopWaitingFrame{LeastUnacked: 7},
 		}))
 	})
 
@@ -197,8 +193,8 @@ var _ = Describe("Packet unpacker", func() {
 		setData([]byte{0x07})
 		packet, err := unpacker.Unpack(hdrBin, hdr, data)
 		Expect(err).ToNot(HaveOccurred())
-		Expect(packet.frames).To(Equal([]frames.Frame{
-			&frames.PingFrame{},
+		Expect(packet.frames).To(Equal([]wire.Frame{
+			&wire.PingFrame{},
 		}))
 	})
 
@@ -228,7 +224,7 @@ var _ = Describe("Packet unpacker", func() {
 	Context("unpacking STREAM frames", func() {
 		It("unpacks unencrypted STREAM frames on stream 1", func() {
 			unpacker.aead.(*mockAEAD).encLevelOpen = protocol.EncryptionUnencrypted
-			f := &frames.StreamFrame{
+			f := &wire.StreamFrame{
 				StreamID: 1,
 				Data:     []byte("foobar"),
 			}
@@ -237,12 +233,12 @@ var _ = Describe("Packet unpacker", func() {
 			setData(buf.Bytes())
 			packet, err := unpacker.Unpack(hdrBin, hdr, data)
 			Expect(err).ToNot(HaveOccurred())
-			Expect(packet.frames).To(Equal([]frames.Frame{f}))
+			Expect(packet.frames).To(Equal([]wire.Frame{f}))
 		})
 
 		It("unpacks encrypted STREAM frames on stream 1", func() {
 			unpacker.aead.(*mockAEAD).encLevelOpen = protocol.EncryptionSecure
-			f := &frames.StreamFrame{
+			f := &wire.StreamFrame{
 				StreamID: 1,
 				Data:     []byte("foobar"),
 			}
@@ -251,12 +247,12 @@ var _ = Describe("Packet unpacker", func() {
 			setData(buf.Bytes())
 			packet, err := unpacker.Unpack(hdrBin, hdr, data)
 			Expect(err).ToNot(HaveOccurred())
-			Expect(packet.frames).To(Equal([]frames.Frame{f}))
+			Expect(packet.frames).To(Equal([]wire.Frame{f}))
 		})
 
 		It("does not unpack unencrypted STREAM frames on higher streams", func() {
 			unpacker.aead.(*mockAEAD).encLevelOpen = protocol.EncryptionUnencrypted
-			f := &frames.StreamFrame{
+			f := &wire.StreamFrame{
 				StreamID: 3,
 				Data:     []byte("foobar"),
 			}
diff --git a/server.go b/server.go
index b45b760b0..8ff54792c 100644
--- a/server.go
+++ b/server.go
@@ -10,8 +10,9 @@ import (
 
 	"github.com/lucas-clemente/quic-go/crypto"
 	"github.com/lucas-clemente/quic-go/handshake"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
@@ -212,7 +213,7 @@ func (s *server) handlePacket(pconn net.PacketConn, remoteAddr net.Addr, packet
 	rcvTime := time.Now()
 
 	r := bytes.NewReader(packet)
-	connID, err := peekConnectionID(r, protocol.PerspectiveClient)
+	connID, err := wire.PeekConnectionID(r, protocol.PerspectiveClient)
 	if err != nil {
 		return qerr.Error(qerr.InvalidPacketHeader, err.Error())
 	}
@@ -231,9 +232,9 @@ func (s *server) handlePacket(pconn net.PacketConn, remoteAddr net.Addr, packet
 		version = session.GetVersion()
 	}
 
-	hdr, err := ParsePublicHeader(r, protocol.PerspectiveClient, version)
-	if err == errPacketWithUnknownVersion {
-		_, err = pconn.WriteTo(writePublicReset(connID, 0, 0), remoteAddr)
+	hdr, err := wire.ParsePublicHeader(r, protocol.PerspectiveClient, version)
+	if err == wire.ErrPacketWithUnknownVersion {
+		_, err = pconn.WriteTo(wire.WritePublicReset(connID, 0, 0), remoteAddr)
 		return err
 	}
 	if err != nil {
@@ -244,12 +245,12 @@ func (s *server) handlePacket(pconn net.PacketConn, remoteAddr net.Addr, packet
 	// ignore all Public Reset packets
 	if hdr.ResetFlag {
 		if ok {
-			var pr *publicReset
-			pr, err = parsePublicReset(r)
+			var pr *wire.PublicReset
+			pr, err = wire.ParsePublicReset(r)
 			if err != nil {
 				utils.Infof("Received a Public Reset for connection %x. An error occurred parsing the packet.")
 			} else {
-				utils.Infof("Received a Public Reset for connection %x, rejected packet number: 0x%x.", hdr.ConnectionID, pr.rejectedPacketNumber)
+				utils.Infof("Received a Public Reset for connection %x, rejected packet number: 0x%x.", hdr.ConnectionID, pr.RejectedPacketNumber)
 			}
 		} else {
 			utils.Infof("Received Public Reset for unknown connection %x.", hdr.ConnectionID)
@@ -271,7 +272,7 @@ func (s *server) handlePacket(pconn net.PacketConn, remoteAddr net.Addr, packet
 			return errors.New("dropping small packet with unknown version")
 		}
 		utils.Infof("Client offered version %d, sending VersionNegotiationPacket", hdr.VersionNumber)
-		_, err = pconn.WriteTo(composeVersionNegotiation(hdr.ConnectionID, s.config.Versions), remoteAddr)
+		_, err = pconn.WriteTo(wire.ComposeVersionNegotiation(hdr.ConnectionID, s.config.Versions), remoteAddr)
 		return err
 	}
 
@@ -337,20 +338,3 @@ func (s *server) removeConnection(id protocol.ConnectionID) {
 		s.sessionsMutex.Unlock()
 	})
 }
-
-func composeVersionNegotiation(connectionID protocol.ConnectionID, versions []protocol.VersionNumber) []byte {
-	fullReply := &bytes.Buffer{}
-	responsePublicHeader := PublicHeader{
-		ConnectionID: connectionID,
-		PacketNumber: 1,
-		VersionFlag:  true,
-	}
-	err := responsePublicHeader.Write(fullReply, protocol.VersionWhatever, protocol.PerspectiveServer)
-	if err != nil {
-		utils.Errorf("error composing version negotiation packet: %s", err.Error())
-	}
-	for _, v := range versions {
-		utils.LittleEndian.WriteUint32(fullReply, protocol.VersionNumberToTag(v))
-	}
-	return fullReply.Bytes()
-}
diff --git a/server_test.go b/server_test.go
index bc26a2ecb..679b2bec4 100644
--- a/server_test.go
+++ b/server_test.go
@@ -11,8 +11,9 @@ import (
 
 	"github.com/lucas-clemente/quic-go/crypto"
 	"github.com/lucas-clemente/quic-go/handshake"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	"github.com/lucas-clemente/quic-go/qerr"
 
 	. "github.com/onsi/ginkgo"
@@ -128,14 +129,6 @@ var _ = Describe("Server", func() {
 			Expect(serv.Addr().String()).To(Equal("192.168.13.37:1234"))
 		})
 
-		It("composes version negotiation packets", func() {
-			expected := append(
-				[]byte{0x01 | 0x08, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-				[]byte{'Q', '0', '9', '9'}...,
-			)
-			Expect(composeVersionNegotiation(1, []protocol.VersionNumber{99})).To(Equal(expected))
-		})
-
 		It("creates new sessions", func() {
 			err := serv.handlePacket(nil, nil, firstPacket)
 			Expect(err).ToNot(HaveOccurred())
@@ -306,7 +299,7 @@ var _ = Describe("Server", func() {
 		})
 
 		It("ignores public resets for unknown connections", func() {
-			err := serv.handlePacket(nil, nil, writePublicReset(999, 1, 1337))
+			err := serv.handlePacket(nil, nil, wire.WritePublicReset(999, 1, 1337))
 			Expect(err).ToNot(HaveOccurred())
 			Expect(serv.sessions).To(BeEmpty())
 		})
@@ -315,7 +308,7 @@ var _ = Describe("Server", func() {
 			err := serv.handlePacket(nil, nil, firstPacket)
 			Expect(serv.sessions).To(HaveLen(1))
 			Expect(serv.sessions[connID].(*mockSession).packetCount).To(Equal(1))
-			err = serv.handlePacket(nil, nil, writePublicReset(connID, 1, 1337))
+			err = serv.handlePacket(nil, nil, wire.WritePublicReset(connID, 1, 1337))
 			Expect(err).ToNot(HaveOccurred())
 			Expect(serv.sessions).To(HaveLen(1))
 			Expect(serv.sessions[connID].(*mockSession).packetCount).To(Equal(1))
@@ -325,7 +318,7 @@ var _ = Describe("Server", func() {
 			err := serv.handlePacket(nil, nil, firstPacket)
 			Expect(serv.sessions).To(HaveLen(1))
 			Expect(serv.sessions[connID].(*mockSession).packetCount).To(Equal(1))
-			data := writePublicReset(connID, 1, 1337)
+			data := wire.WritePublicReset(connID, 1, 1337)
 			err = serv.handlePacket(nil, nil, data[:len(data)-2])
 			Expect(err).ToNot(HaveOccurred())
 			Expect(serv.sessions).To(HaveLen(1))
@@ -334,7 +327,7 @@ var _ = Describe("Server", func() {
 
 		It("doesn't respond with a version negotiation packet if the first packet is too small", func() {
 			b := &bytes.Buffer{}
-			hdr := PublicHeader{
+			hdr := wire.PublicHeader{
 				VersionFlag:     true,
 				ConnectionID:    0x1337,
 				PacketNumber:    1,
@@ -402,7 +395,7 @@ var _ = Describe("Server", func() {
 	It("setups and responds with version negotiation", func() {
 		config.Versions = []protocol.VersionNumber{99}
 		b := &bytes.Buffer{}
-		hdr := PublicHeader{
+		hdr := wire.PublicHeader{
 			VersionFlag:     true,
 			ConnectionID:    0x1337,
 			PacketNumber:    1,
diff --git a/session.go b/session.go
index 49c170428..ede58cfd5 100644
--- a/session.go
+++ b/session.go
@@ -11,21 +11,21 @@ import (
 
 	"github.com/lucas-clemente/quic-go/ackhandler"
 	"github.com/lucas-clemente/quic-go/congestion"
-	"github.com/lucas-clemente/quic-go/flowcontrol"
-	"github.com/lucas-clemente/quic-go/frames"
 	"github.com/lucas-clemente/quic-go/handshake"
+	"github.com/lucas-clemente/quic-go/internal/flowcontrol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
 type unpacker interface {
-	Unpack(publicHeaderBinary []byte, hdr *PublicHeader, data []byte) (*unpackedPacket, error)
+	Unpack(publicHeaderBinary []byte, hdr *wire.PublicHeader, data []byte) (*unpackedPacket, error)
 }
 
 type receivedPacket struct {
 	remoteAddr   net.Addr
-	publicHeader *PublicHeader
+	publicHeader *wire.PublicHeader
 	data         []byte
 	rcvTime      time.Time
 }
@@ -184,8 +184,8 @@ func (s *session) setup(
 	s.connectionParameters = handshake.NewConnectionParamatersManager(
 		s.perspective,
 		s.version,
-		s.config.MaxReceiveStreamFlowControlWindow,
-		s.config.MaxReceiveConnectionFlowControlWindow,
+		protocol.ByteCount(s.config.MaxReceiveStreamFlowControlWindow),
+		protocol.ByteCount(s.config.MaxReceiveConnectionFlowControlWindow),
 		s.config.IdleTimeout,
 	)
 	s.sentPacketHandler = ackhandler.NewSentPacketHandler(s.rttStats)
@@ -313,7 +313,7 @@ runLoop:
 
 		if s.config.KeepAlive && s.handshakeComplete && time.Since(s.lastNetworkActivityTime) >= s.idleTimeout()/2 {
 			// send the PING frame since there is no activity in the session
-			s.packer.QueueControlFrame(&frames.PingFrame{})
+			s.packer.QueueControlFrame(&wire.PingFrame{})
 			s.keepAlivePingSent = true
 		}
 
@@ -434,29 +434,29 @@ func (s *session) handlePacketImpl(p *receivedPacket) error {
 	return s.handleFrames(packet.frames)
 }
 
-func (s *session) handleFrames(fs []frames.Frame) error {
+func (s *session) handleFrames(fs []wire.Frame) error {
 	for _, ff := range fs {
 		var err error
-		frames.LogFrame(ff, false)
+		wire.LogFrame(ff, false)
 		switch frame := ff.(type) {
-		case *frames.StreamFrame:
+		case *wire.StreamFrame:
 			err = s.handleStreamFrame(frame)
-		case *frames.AckFrame:
+		case *wire.AckFrame:
 			err = s.handleAckFrame(frame)
-		case *frames.ConnectionCloseFrame:
+		case *wire.ConnectionCloseFrame:
 			s.closeRemote(qerr.Error(frame.ErrorCode, frame.ReasonPhrase))
-		case *frames.GoawayFrame:
+		case *wire.GoawayFrame:
 			err = errors.New("unimplemented: handling GOAWAY frames")
-		case *frames.StopWaitingFrame:
+		case *wire.StopWaitingFrame:
 			// LeastUnacked is guaranteed to have LeastUnacked > 0
 			// therefore this will never underflow
 			s.receivedPacketHandler.SetLowerLimit(frame.LeastUnacked - 1)
-		case *frames.RstStreamFrame:
+		case *wire.RstStreamFrame:
 			err = s.handleRstStreamFrame(frame)
-		case *frames.WindowUpdateFrame:
+		case *wire.WindowUpdateFrame:
 			err = s.handleWindowUpdateFrame(frame)
-		case *frames.BlockedFrame:
-		case *frames.PingFrame:
+		case *wire.BlockedFrame:
+		case *wire.PingFrame:
 		default:
 			return errors.New("Session BUG: unexpected frame type")
 		}
@@ -488,7 +488,7 @@ func (s *session) handlePacket(p *receivedPacket) {
 	}
 }
 
-func (s *session) handleStreamFrame(frame *frames.StreamFrame) error {
+func (s *session) handleStreamFrame(frame *wire.StreamFrame) error {
 	str, err := s.streamsMap.GetOrOpenStream(frame.StreamID)
 	if err != nil {
 		return err
@@ -501,7 +501,7 @@ func (s *session) handleStreamFrame(frame *frames.StreamFrame) error {
 	return str.AddStreamFrame(frame)
 }
 
-func (s *session) handleWindowUpdateFrame(frame *frames.WindowUpdateFrame) error {
+func (s *session) handleWindowUpdateFrame(frame *wire.WindowUpdateFrame) error {
 	if frame.StreamID != 0 {
 		str, err := s.streamsMap.GetOrOpenStream(frame.StreamID)
 		if err != nil {
@@ -515,7 +515,7 @@ func (s *session) handleWindowUpdateFrame(frame *frames.WindowUpdateFrame) error
 	return err
 }
 
-func (s *session) handleRstStreamFrame(frame *frames.RstStreamFrame) error {
+func (s *session) handleRstStreamFrame(frame *wire.RstStreamFrame) error {
 	str, err := s.streamsMap.GetOrOpenStream(frame.StreamID)
 	if err != nil {
 		return err
@@ -528,7 +528,7 @@ func (s *session) handleRstStreamFrame(frame *frames.RstStreamFrame) error {
 	return s.flowControlManager.ResetStream(frame.StreamID, frame.ByteOffset)
 }
 
-func (s *session) handleAckFrame(frame *frames.AckFrame) error {
+func (s *session) handleAckFrame(frame *wire.AckFrame) error {
 	return s.sentPacketHandler.ReceivedAck(frame, s.lastRcvdPacketNumber, s.lastNetworkActivityTime)
 }
 
@@ -647,9 +647,9 @@ func (s *session) sendPacket() error {
 				// resend the frames that were in the packet
 				for _, frame := range retransmitPacket.GetFramesForRetransmission() {
 					switch f := frame.(type) {
-					case *frames.StreamFrame:
+					case *wire.StreamFrame:
 						s.streamFramer.AddFrameForRetransmission(f)
-					case *frames.WindowUpdateFrame:
+					case *wire.WindowUpdateFrame:
 						// only retransmit WindowUpdates if the stream is not yet closed and the we haven't sent another WindowUpdate with a higher ByteOffset for the stream
 						currentOffset, err := s.flowControlManager.GetReceiveWindow(f.StreamID)
 						if err == nil && f.ByteOffset >= currentOffset {
@@ -671,7 +671,7 @@ func (s *session) sendPacket() error {
 		}
 		// add a retransmittable frame
 		if s.sentPacketHandler.ShouldSendRetransmittablePacket() {
-			s.packer.QueueControlFrame(&frames.PingFrame{})
+			s.packer.QueueControlFrame(&wire.PingFrame{})
 		}
 		packet, err := s.packer.PackPacket()
 		if err != nil || packet == nil {
@@ -707,7 +707,7 @@ func (s *session) sendPackedPacket(packet *packedPacket) error {
 
 func (s *session) sendConnectionClose(quicErr *qerr.QuicError) error {
 	s.packer.SetLeastUnacked(s.sentPacketHandler.GetLeastUnacked())
-	packet, err := s.packer.PackConnectionClose(&frames.ConnectionCloseFrame{
+	packet, err := s.packer.PackConnectionClose(&wire.ConnectionCloseFrame{
 		ErrorCode:    quicErr.ErrorCode,
 		ReasonPhrase: quicErr.ErrorMessage,
 	})
@@ -725,7 +725,7 @@ func (s *session) logPacket(packet *packedPacket) {
 	}
 	utils.Debugf("-> Sending packet 0x%x (%d bytes) for connection %x, %s", packet.number, len(packet.raw), s.connectionID, packet.encryptionLevel)
 	for _, frame := range packet.frames {
-		frames.LogFrame(frame, true)
+		wire.LogFrame(frame, true)
 	}
 }
 
@@ -759,7 +759,7 @@ func (s *session) WaitUntilHandshakeComplete() error {
 }
 
 func (s *session) queueResetStreamFrame(id protocol.StreamID, offset protocol.ByteCount) {
-	s.packer.QueueControlFrame(&frames.RstStreamFrame{
+	s.packer.QueueControlFrame(&wire.RstStreamFrame{
 		StreamID:   id,
 		ByteOffset: offset,
 	})
@@ -794,7 +794,7 @@ func (s *session) garbageCollectStreams() {
 
 func (s *session) sendPublicReset(rejectedPacketNumber protocol.PacketNumber) error {
 	utils.Infof("Sending public reset for connection %x, packet number %d", s.connectionID, rejectedPacketNumber)
-	return s.conn.Write(writePublicReset(s.connectionID, rejectedPacketNumber, 0))
+	return s.conn.Write(wire.WritePublicReset(s.connectionID, rejectedPacketNumber, 0))
 }
 
 // scheduleSending signals that we have data for sending
@@ -830,11 +830,11 @@ func (s *session) tryDecryptingQueuedPackets() {
 	s.undecryptablePackets = s.undecryptablePackets[:0]
 }
 
-func (s *session) getWindowUpdateFrames() []*frames.WindowUpdateFrame {
+func (s *session) getWindowUpdateFrames() []*wire.WindowUpdateFrame {
 	updates := s.flowControlManager.GetWindowUpdates()
-	res := make([]*frames.WindowUpdateFrame, len(updates))
+	res := make([]*wire.WindowUpdateFrame, len(updates))
 	for i, u := range updates {
-		res[i] = &frames.WindowUpdateFrame{StreamID: u.StreamID, ByteOffset: u.Offset}
+		res[i] = &wire.WindowUpdateFrame{StreamID: u.StreamID, ByteOffset: u.Offset}
 	}
 	return res
 }
diff --git a/session_test.go b/session_test.go
index 80b11bda7..8805a275f 100644
--- a/session_test.go
+++ b/session_test.go
@@ -16,12 +16,12 @@ import (
 
 	"github.com/lucas-clemente/quic-go/ackhandler"
 	"github.com/lucas-clemente/quic-go/crypto"
-	"github.com/lucas-clemente/quic-go/frames"
 	"github.com/lucas-clemente/quic-go/handshake"
 	"github.com/lucas-clemente/quic-go/internal/mocks"
 	"github.com/lucas-clemente/quic-go/internal/mocks/mocks_fc"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/testdata"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
@@ -61,7 +61,7 @@ type mockUnpacker struct {
 	unpackErr error
 }
 
-func (m *mockUnpacker) Unpack(publicHeaderBinary []byte, hdr *PublicHeader, data []byte) (*unpackedPacket, error) {
+func (m *mockUnpacker) Unpack(publicHeaderBinary []byte, hdr *wire.PublicHeader, data []byte) (*unpackedPacket, error) {
 	if m.unpackErr != nil {
 		return nil, m.unpackErr
 	}
@@ -83,7 +83,7 @@ func (h *mockSentPacketHandler) SentPacket(packet *ackhandler.Packet) error {
 	return nil
 }
 
-func (h *mockSentPacketHandler) ReceivedAck(ackFrame *frames.AckFrame, withPacketNumber protocol.PacketNumber, recvTime time.Time) error {
+func (h *mockSentPacketHandler) ReceivedAck(ackFrame *wire.AckFrame, withPacketNumber protocol.PacketNumber, recvTime time.Time) error {
 	return nil
 }
 
@@ -97,9 +97,9 @@ func (h *mockSentPacketHandler) ShouldSendRetransmittablePacket() bool {
 	return b
 }
 
-func (h *mockSentPacketHandler) GetStopWaitingFrame(force bool) *frames.StopWaitingFrame {
+func (h *mockSentPacketHandler) GetStopWaitingFrame(force bool) *wire.StopWaitingFrame {
 	h.requestedStopWaiting = true
-	return &frames.StopWaitingFrame{LeastUnacked: 0x1337}
+	return &wire.StopWaitingFrame{LeastUnacked: 0x1337}
 }
 
 func (h *mockSentPacketHandler) DequeuePacketForRetransmission() *ackhandler.Packet {
@@ -118,11 +118,11 @@ func newMockSentPacketHandler() ackhandler.SentPacketHandler {
 var _ ackhandler.SentPacketHandler = &mockSentPacketHandler{}
 
 type mockReceivedPacketHandler struct {
-	nextAckFrame *frames.AckFrame
+	nextAckFrame *wire.AckFrame
 	ackAlarm     time.Time
 }
 
-func (m *mockReceivedPacketHandler) GetAckFrame() *frames.AckFrame {
+func (m *mockReceivedPacketHandler) GetAckFrame() *wire.AckFrame {
 	f := m.nextAckFrame
 	m.nextAckFrame = nil
 	return f
@@ -263,7 +263,7 @@ var _ = Describe("Session", func() {
 
 	Context("when handling stream frames", func() {
 		It("makes new streams", func() {
-			sess.handleStreamFrame(&frames.StreamFrame{
+			sess.handleStreamFrame(&wire.StreamFrame{
 				StreamID: 5,
 				Data:     []byte{0xde, 0xca, 0xfb, 0xad},
 			})
@@ -279,7 +279,7 @@ var _ = Describe("Session", func() {
 		It("does not reject existing streams with even StreamIDs", func() {
 			_, err := sess.GetOrOpenStream(5)
 			Expect(err).ToNot(HaveOccurred())
-			err = sess.handleStreamFrame(&frames.StreamFrame{
+			err = sess.handleStreamFrame(&wire.StreamFrame{
 				StreamID: 5,
 				Data:     []byte{0xde, 0xca, 0xfb, 0xad},
 			})
@@ -287,12 +287,12 @@ var _ = Describe("Session", func() {
 		})
 
 		It("handles existing streams", func() {
-			sess.handleStreamFrame(&frames.StreamFrame{
+			sess.handleStreamFrame(&wire.StreamFrame{
 				StreamID: 5,
 				Data:     []byte{0xde, 0xca},
 			})
 			numOpenStreams := len(sess.streamsMap.openStreams)
-			sess.handleStreamFrame(&frames.StreamFrame{
+			sess.handleStreamFrame(&wire.StreamFrame{
 				StreamID: 5,
 				Offset:   2,
 				Data:     []byte{0xfb, 0xad},
@@ -317,7 +317,7 @@ var _ = Describe("Session", func() {
 		})
 
 		It("does not delete streams with FIN bit", func() {
-			sess.handleStreamFrame(&frames.StreamFrame{
+			sess.handleStreamFrame(&wire.StreamFrame{
 				StreamID: 5,
 				Data:     []byte{0xde, 0xca, 0xfb, 0xad},
 				FinBit:   true,
@@ -336,7 +336,7 @@ var _ = Describe("Session", func() {
 		})
 
 		It("deletes streams with FIN bit & close", func() {
-			sess.handleStreamFrame(&frames.StreamFrame{
+			sess.handleStreamFrame(&wire.StreamFrame{
 				StreamID: 5,
 				Data:     []byte{0xde, 0xca, 0xfb, 0xad},
 				FinBit:   true,
@@ -369,7 +369,7 @@ var _ = Describe("Session", func() {
 		It("cancels streams with error", func() {
 			sess.garbageCollectStreams()
 			testErr := errors.New("test")
-			sess.handleStreamFrame(&frames.StreamFrame{
+			sess.handleStreamFrame(&wire.StreamFrame{
 				StreamID: 5,
 				Data:     []byte{0xde, 0xca, 0xfb, 0xad},
 			})
@@ -413,7 +413,7 @@ var _ = Describe("Session", func() {
 		})
 
 		It("ignores STREAM frames for closed streams (client-side)", func() {
-			sess.handleStreamFrame(&frames.StreamFrame{
+			sess.handleStreamFrame(&wire.StreamFrame{
 				StreamID: 5,
 				FinBit:   true,
 			})
@@ -426,7 +426,7 @@ var _ = Describe("Session", func() {
 			sess.garbageCollectStreams()
 			str, _ = sess.streamsMap.GetOrOpenStream(5)
 			Expect(str).To(BeNil()) // make sure the stream is gone
-			err = sess.handleStreamFrame(&frames.StreamFrame{
+			err = sess.handleStreamFrame(&wire.StreamFrame{
 				StreamID: 5,
 				Data:     []byte("foobar"),
 			})
@@ -437,7 +437,7 @@ var _ = Describe("Session", func() {
 			ostr, err := sess.OpenStream()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(ostr.StreamID()).To(Equal(protocol.StreamID(2)))
-			err = sess.handleStreamFrame(&frames.StreamFrame{
+			err = sess.handleStreamFrame(&wire.StreamFrame{
 				StreamID: 2,
 				FinBit:   true,
 			})
@@ -451,7 +451,7 @@ var _ = Describe("Session", func() {
 			sess.garbageCollectStreams()
 			str, _ = sess.streamsMap.GetOrOpenStream(2)
 			Expect(str).To(BeNil()) // make sure the stream is gone
-			err = sess.handleStreamFrame(&frames.StreamFrame{
+			err = sess.handleStreamFrame(&wire.StreamFrame{
 				StreamID: 2,
 				FinBit:   true,
 			})
@@ -463,7 +463,7 @@ var _ = Describe("Session", func() {
 		It("closes the streams for writing", func() {
 			s, err := sess.GetOrOpenStream(5)
 			Expect(err).ToNot(HaveOccurred())
-			err = sess.handleRstStreamFrame(&frames.RstStreamFrame{
+			err = sess.handleRstStreamFrame(&wire.RstStreamFrame{
 				StreamID:  5,
 				ErrorCode: 42,
 			})
@@ -476,11 +476,11 @@ var _ = Describe("Session", func() {
 		It("doesn't close the stream for reading", func() {
 			s, err := sess.GetOrOpenStream(5)
 			Expect(err).ToNot(HaveOccurred())
-			sess.handleStreamFrame(&frames.StreamFrame{
+			sess.handleStreamFrame(&wire.StreamFrame{
 				StreamID: 5,
 				Data:     []byte("foobar"),
 			})
-			err = sess.handleRstStreamFrame(&frames.RstStreamFrame{
+			err = sess.handleRstStreamFrame(&wire.RstStreamFrame{
 				StreamID:   5,
 				ErrorCode:  42,
 				ByteOffset: 6,
@@ -496,12 +496,12 @@ var _ = Describe("Session", func() {
 			str, err := sess.GetOrOpenStream(5)
 			Expect(err).ToNot(HaveOccurred())
 			str.(*stream).writeOffset = 0x1337
-			err = sess.handleRstStreamFrame(&frames.RstStreamFrame{
+			err = sess.handleRstStreamFrame(&wire.RstStreamFrame{
 				StreamID: 5,
 			})
 			Expect(err).ToNot(HaveOccurred())
 			Expect(sess.packer.controlFrames).To(HaveLen(1))
-			Expect(sess.packer.controlFrames[0].(*frames.RstStreamFrame)).To(Equal(&frames.RstStreamFrame{
+			Expect(sess.packer.controlFrames[0].(*wire.RstStreamFrame)).To(Equal(&wire.RstStreamFrame{
 				StreamID:   5,
 				ByteOffset: 0x1337,
 			}))
@@ -513,7 +513,7 @@ var _ = Describe("Session", func() {
 			Expect(err).NotTo(HaveOccurred())
 			str.(*stream).sentFin()
 			str.Close()
-			err = sess.handleRstStreamFrame(&frames.RstStreamFrame{
+			err = sess.handleRstStreamFrame(&wire.RstStreamFrame{
 				StreamID: 5,
 			})
 			Expect(err).ToNot(HaveOccurred())
@@ -526,7 +526,7 @@ var _ = Describe("Session", func() {
 			fcm := mocks_fc.NewMockFlowControlManager(mockCtrl)
 			sess.flowControlManager = fcm
 			fcm.EXPECT().ResetStream(protocol.StreamID(5), protocol.ByteCount(0x1337))
-			err := sess.handleRstStreamFrame(&frames.RstStreamFrame{
+			err := sess.handleRstStreamFrame(&wire.RstStreamFrame{
 				StreamID:   5,
 				ByteOffset: 0x1337,
 			})
@@ -539,7 +539,7 @@ var _ = Describe("Session", func() {
 			fcm := mocks_fc.NewMockFlowControlManager(mockCtrl)
 			sess.flowControlManager = fcm
 			fcm.EXPECT().ResetStream(protocol.StreamID(5), protocol.ByteCount(0x1337)).Return(testErr)
-			err := sess.handleRstStreamFrame(&frames.RstStreamFrame{
+			err := sess.handleRstStreamFrame(&wire.RstStreamFrame{
 				StreamID:   5,
 				ByteOffset: 0x1337,
 			})
@@ -547,7 +547,7 @@ var _ = Describe("Session", func() {
 		})
 
 		It("ignores the error when the stream is not known", func() {
-			err := sess.handleFrames([]frames.Frame{&frames.RstStreamFrame{
+			err := sess.handleFrames([]wire.Frame{&wire.RstStreamFrame{
 				StreamID:  5,
 				ErrorCode: 42,
 			}})
@@ -561,7 +561,7 @@ var _ = Describe("Session", func() {
 			Expect(err).ToNot(HaveOccurred())
 			str.Reset(testErr)
 			Expect(sess.packer.controlFrames).To(HaveLen(1))
-			Expect(sess.packer.controlFrames[0]).To(Equal(&frames.RstStreamFrame{
+			Expect(sess.packer.controlFrames[0]).To(Equal(&wire.RstStreamFrame{
 				StreamID:   5,
 				ByteOffset: 0x1337,
 			}))
@@ -574,7 +574,7 @@ var _ = Describe("Session", func() {
 			Expect(err).ToNot(HaveOccurred())
 			str.Reset(testErr)
 			Expect(sess.packer.controlFrames).To(HaveLen(1))
-			err = sess.handleRstStreamFrame(&frames.RstStreamFrame{
+			err = sess.handleRstStreamFrame(&wire.RstStreamFrame{
 				StreamID:   5,
 				ByteOffset: 0x42,
 			})
@@ -587,7 +587,7 @@ var _ = Describe("Session", func() {
 		It("updates the Flow Control Window of a stream", func() {
 			_, err := sess.GetOrOpenStream(5)
 			Expect(err).ToNot(HaveOccurred())
-			err = sess.handleWindowUpdateFrame(&frames.WindowUpdateFrame{
+			err = sess.handleWindowUpdateFrame(&wire.WindowUpdateFrame{
 				StreamID:   5,
 				ByteOffset: 100,
 			})
@@ -596,7 +596,7 @@ var _ = Describe("Session", func() {
 		})
 
 		It("updates the Flow Control Window of the connection", func() {
-			err := sess.handleWindowUpdateFrame(&frames.WindowUpdateFrame{
+			err := sess.handleWindowUpdateFrame(&wire.WindowUpdateFrame{
 				StreamID:   0,
 				ByteOffset: 0x800000,
 			})
@@ -604,7 +604,7 @@ var _ = Describe("Session", func() {
 		})
 
 		It("opens a new stream when receiving a WINDOW_UPDATE for an unknown stream", func() {
-			err := sess.handleWindowUpdateFrame(&frames.WindowUpdateFrame{
+			err := sess.handleWindowUpdateFrame(&wire.WindowUpdateFrame{
 				StreamID:   5,
 				ByteOffset: 1337,
 			})
@@ -615,11 +615,11 @@ var _ = Describe("Session", func() {
 		})
 
 		It("errors when receiving a WindowUpdateFrame for a closed stream", func() {
-			sess.handleStreamFrame(&frames.StreamFrame{StreamID: 5})
+			sess.handleStreamFrame(&wire.StreamFrame{StreamID: 5})
 			err := sess.streamsMap.RemoveStream(5)
 			Expect(err).ToNot(HaveOccurred())
 			sess.garbageCollectStreams()
-			err = sess.handleWindowUpdateFrame(&frames.WindowUpdateFrame{
+			err = sess.handleWindowUpdateFrame(&wire.WindowUpdateFrame{
 				StreamID:   5,
 				ByteOffset: 1337,
 			})
@@ -627,11 +627,11 @@ var _ = Describe("Session", func() {
 		})
 
 		It("ignores errors when receiving a WindowUpdateFrame for a closed stream", func() {
-			sess.handleStreamFrame(&frames.StreamFrame{StreamID: 5})
+			sess.handleStreamFrame(&wire.StreamFrame{StreamID: 5})
 			err := sess.streamsMap.RemoveStream(5)
 			Expect(err).ToNot(HaveOccurred())
 			sess.garbageCollectStreams()
-			err = sess.handleFrames([]frames.Frame{&frames.WindowUpdateFrame{
+			err = sess.handleFrames([]wire.Frame{&wire.WindowUpdateFrame{
 				StreamID:   5,
 				ByteOffset: 1337,
 			}})
@@ -640,29 +640,29 @@ var _ = Describe("Session", func() {
 	})
 
 	It("handles PING frames", func() {
-		err := sess.handleFrames([]frames.Frame{&frames.PingFrame{}})
+		err := sess.handleFrames([]wire.Frame{&wire.PingFrame{}})
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	It("handles BLOCKED frames", func() {
-		err := sess.handleFrames([]frames.Frame{&frames.BlockedFrame{}})
+		err := sess.handleFrames([]wire.Frame{&wire.BlockedFrame{}})
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	It("errors on GOAWAY frames", func() {
-		err := sess.handleFrames([]frames.Frame{&frames.GoawayFrame{}})
+		err := sess.handleFrames([]wire.Frame{&wire.GoawayFrame{}})
 		Expect(err).To(MatchError("unimplemented: handling GOAWAY frames"))
 	})
 
 	It("handles STOP_WAITING frames", func() {
-		err := sess.handleFrames([]frames.Frame{&frames.StopWaitingFrame{LeastUnacked: 10}})
+		err := sess.handleFrames([]wire.Frame{&wire.StopWaitingFrame{LeastUnacked: 10}})
 		Expect(err).NotTo(HaveOccurred())
 	})
 
 	It("handles CONNECTION_CLOSE frames", func(done Done) {
 		go sess.run()
 		str, _ := sess.GetOrOpenStream(5)
-		err := sess.handleFrames([]frames.Frame{&frames.ConnectionCloseFrame{ErrorCode: 42, ReasonPhrase: "foobar"}})
+		err := sess.handleFrames([]wire.Frame{&wire.ConnectionCloseFrame{ErrorCode: 42, ReasonPhrase: "foobar"}})
 		Expect(err).NotTo(HaveOccurred())
 		Eventually(sess.Context().Done()).Should(BeClosed())
 		_, err = str.Read([]byte{0})
@@ -738,7 +738,7 @@ var _ = Describe("Session", func() {
 				Expect(err).ToNot(HaveOccurred())
 			}()
 			Consistently(func() Stream { return str }).Should(BeNil())
-			sess.handleStreamFrame(&frames.StreamFrame{
+			sess.handleStreamFrame(&wire.StreamFrame{
 				StreamID: 3,
 			})
 			Eventually(func() Stream { return str }).ShouldNot(BeNil())
@@ -847,11 +847,11 @@ var _ = Describe("Session", func() {
 	})
 
 	Context("receiving packets", func() {
-		var hdr *PublicHeader
+		var hdr *wire.PublicHeader
 
 		BeforeEach(func() {
 			sess.unpacker = &mockUnpacker{}
-			hdr = &PublicHeader{PacketNumberLen: protocol.PacketNumberLen6}
+			hdr = &wire.PublicHeader{PacketNumberLen: protocol.PacketNumberLen6}
 		})
 
 		It("sets the {last,largest}RcvdPacketNumber", func() {
@@ -903,7 +903,7 @@ var _ = Describe("Session", func() {
 				Expect(sess.conn.(*mockConnection).remoteAddr).ToNot(Equal(remoteIP))
 				p := receivedPacket{
 					remoteAddr:   remoteIP,
-					publicHeader: &PublicHeader{PacketNumber: 1337},
+					publicHeader: &wire.PublicHeader{PacketNumber: 1337},
 				}
 				err := sess.handlePacketImpl(&p)
 				Expect(err).ToNot(HaveOccurred())
@@ -919,7 +919,7 @@ var _ = Describe("Session", func() {
 				sess.unpacker.(*packetUnpacker).aead = &mockAEAD{}
 				p := receivedPacket{
 					remoteAddr:   attackerIP,
-					publicHeader: &PublicHeader{PacketNumber: 1337},
+					publicHeader: &wire.PublicHeader{PacketNumber: 1337},
 				}
 				err := sess.handlePacketImpl(&p)
 				quicErr := err.(*qerr.QuicError)
@@ -933,7 +933,7 @@ var _ = Describe("Session", func() {
 				Expect(sess.conn.(*mockConnection).remoteAddr).ToNot(Equal(remoteIP))
 				p := receivedPacket{
 					remoteAddr:   remoteIP,
-					publicHeader: &PublicHeader{PacketNumber: 1337},
+					publicHeader: &wire.PublicHeader{PacketNumber: 1337},
 				}
 				sess.unpacker.(*mockUnpacker).unpackErr = testErr
 				err := sess.handlePacketImpl(&p)
@@ -969,7 +969,7 @@ var _ = Describe("Session", func() {
 			err := sess.sendPacket()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(mconn.written).To(HaveLen(1))
-			Expect(sess.sentPacketHandler.(*mockSentPacketHandler).sentPackets[0].Frames).To(ContainElement(&frames.PingFrame{}))
+			Expect(sess.sentPacketHandler.(*mockSentPacketHandler).sentPackets[0].Frames).To(ContainElement(&wire.PingFrame{}))
 		})
 
 		It("sends two WindowUpdate frames", func() {
@@ -999,7 +999,7 @@ var _ = Describe("Session", func() {
 			sess.packer.packetNumberGenerator.next = 0x1337 + 9
 			sess.packer.cryptoSetup = &mockCryptoSetup{encLevelSeal: protocol.EncryptionForwardSecure}
 
-			f := &frames.StreamFrame{
+			f := &wire.StreamFrame{
 				StreamID: 5,
 				Data:     []byte("foobar"),
 			}
@@ -1030,9 +1030,9 @@ var _ = Describe("Session", func() {
 
 		Context("for handshake packets", func() {
 			It("retransmits an unencrypted packet", func() {
-				sf := &frames.StreamFrame{StreamID: 1, Data: []byte("foobar")}
+				sf := &wire.StreamFrame{StreamID: 1, Data: []byte("foobar")}
 				sph.retransmissionQueue = []*ackhandler.Packet{{
-					Frames:          []frames.Frame{sf},
+					Frames:          []wire.Frame{sf},
 					EncryptionLevel: protocol.EncryptionUnencrypted,
 				}}
 				err := sess.sendPacket()
@@ -1043,14 +1043,14 @@ var _ = Describe("Session", func() {
 				Expect(sentPackets[0].EncryptionLevel).To(Equal(protocol.EncryptionUnencrypted))
 				Expect(sentPackets[0].Frames).To(HaveLen(2))
 				Expect(sentPackets[0].Frames[1]).To(Equal(sf))
-				swf := sentPackets[0].Frames[0].(*frames.StopWaitingFrame)
+				swf := sentPackets[0].Frames[0].(*wire.StopWaitingFrame)
 				Expect(swf.LeastUnacked).To(Equal(protocol.PacketNumber(0x1337)))
 			})
 
 			It("retransmit a packet encrypted with the initial encryption", func() {
-				sf := &frames.StreamFrame{StreamID: 1, Data: []byte("foobar")}
+				sf := &wire.StreamFrame{StreamID: 1, Data: []byte("foobar")}
 				sph.retransmissionQueue = []*ackhandler.Packet{{
-					Frames:          []frames.Frame{sf},
+					Frames:          []wire.Frame{sf},
 					EncryptionLevel: protocol.EncryptionSecure,
 				}}
 				err := sess.sendPacket()
@@ -1065,9 +1065,9 @@ var _ = Describe("Session", func() {
 
 			It("doesn't retransmit handshake packets when the handshake is complete", func() {
 				sess.handshakeComplete = true
-				sf := &frames.StreamFrame{StreamID: 1, Data: []byte("foobar")}
+				sf := &wire.StreamFrame{StreamID: 1, Data: []byte("foobar")}
 				sph.retransmissionQueue = []*ackhandler.Packet{{
-					Frames:          []frames.Frame{sf},
+					Frames:          []wire.Frame{sf},
 					EncryptionLevel: protocol.EncryptionSecure,
 				}}
 				err := sess.sendPacket()
@@ -1078,13 +1078,13 @@ var _ = Describe("Session", func() {
 
 		Context("for packets after the handshake", func() {
 			It("sends a StreamFrame from a packet queued for retransmission", func() {
-				f := frames.StreamFrame{
+				f := wire.StreamFrame{
 					StreamID: 0x5,
 					Data:     []byte("foobar1234567"),
 				}
 				p := ackhandler.Packet{
 					PacketNumber:    0x1337,
-					Frames:          []frames.Frame{&f},
+					Frames:          []wire.Frame{&f},
 					EncryptionLevel: protocol.EncryptionForwardSecure,
 				}
 				sph.retransmissionQueue = []*ackhandler.Packet{&p}
@@ -1097,22 +1097,22 @@ var _ = Describe("Session", func() {
 			})
 
 			It("sends a StreamFrame from a packet queued for retransmission", func() {
-				f1 := frames.StreamFrame{
+				f1 := wire.StreamFrame{
 					StreamID: 0x5,
 					Data:     []byte("foobar"),
 				}
-				f2 := frames.StreamFrame{
+				f2 := wire.StreamFrame{
 					StreamID: 0x7,
 					Data:     []byte("loremipsum"),
 				}
 				p1 := ackhandler.Packet{
 					PacketNumber:    0x1337,
-					Frames:          []frames.Frame{&f1},
+					Frames:          []wire.Frame{&f1},
 					EncryptionLevel: protocol.EncryptionForwardSecure,
 				}
 				p2 := ackhandler.Packet{
 					PacketNumber:    0x1338,
-					Frames:          []frames.Frame{&f2},
+					Frames:          []wire.Frame{&f2},
 					EncryptionLevel: protocol.EncryptionForwardSecure,
 				}
 				sph.retransmissionQueue = []*ackhandler.Packet{&p1, &p2}
@@ -1126,7 +1126,7 @@ var _ = Describe("Session", func() {
 			})
 
 			It("always attaches a StopWaiting to a packet that contains a retransmission", func() {
-				f := &frames.StreamFrame{
+				f := &wire.StreamFrame{
 					StreamID: 0x5,
 					Data:     bytes.Repeat([]byte{'f'}, int(1.5*float32(protocol.MaxPacketSize))),
 				}
@@ -1137,9 +1137,9 @@ var _ = Describe("Session", func() {
 				Expect(mconn.written).To(HaveLen(2))
 				sentPackets := sph.sentPackets
 				Expect(sentPackets).To(HaveLen(2))
-				_, ok := sentPackets[0].Frames[0].(*frames.StopWaitingFrame)
+				_, ok := sentPackets[0].Frames[0].(*wire.StopWaitingFrame)
 				Expect(ok).To(BeTrue())
-				_, ok = sentPackets[1].Frames[0].(*frames.StopWaitingFrame)
+				_, ok = sentPackets[1].Frames[0].(*wire.StopWaitingFrame)
 				Expect(ok).To(BeTrue())
 			})
 
@@ -1150,12 +1150,12 @@ var _ = Describe("Session", func() {
 				sess.flowControlManager = fcm
 				fcm.EXPECT().GetWindowUpdates()
 				fcm.EXPECT().GetReceiveWindow(protocol.StreamID(5)).Return(protocol.ByteCount(0x1000), nil)
-				wuf := &frames.WindowUpdateFrame{
+				wuf := &wire.WindowUpdateFrame{
 					StreamID:   5,
 					ByteOffset: 0x1000,
 				}
 				sph.retransmissionQueue = []*ackhandler.Packet{{
-					Frames:          []frames.Frame{wuf},
+					Frames:          []wire.Frame{wuf},
 					EncryptionLevel: protocol.EncryptionForwardSecure,
 				}}
 				err = sess.sendPacket()
@@ -1172,7 +1172,7 @@ var _ = Describe("Session", func() {
 				fcm.EXPECT().GetWindowUpdates()
 				fcm.EXPECT().GetReceiveWindow(protocol.StreamID(5)).Return(protocol.ByteCount(0x2000), nil)
 				sph.retransmissionQueue = []*ackhandler.Packet{{
-					Frames: []frames.Frame{&frames.WindowUpdateFrame{
+					Frames: []wire.Frame{&wire.WindowUpdateFrame{
 						StreamID:   5,
 						ByteOffset: 0x1000,
 					}},
@@ -1194,7 +1194,7 @@ var _ = Describe("Session", func() {
 				_, err = sess.flowControlManager.SendWindowSize(5)
 				Expect(err).To(MatchError("Error accessing the flowController map."))
 				sph.retransmissionQueue = []*ackhandler.Packet{{
-					Frames: []frames.Frame{&frames.WindowUpdateFrame{
+					Frames: []wire.Frame{&wire.WindowUpdateFrame{
 						StreamID:   5,
 						ByteOffset: 0x1337,
 					}},
@@ -1219,7 +1219,7 @@ var _ = Describe("Session", func() {
 		err := sess.sentPacketHandler.SentPacket(&ackhandler.Packet{
 			PacketNumber: n,
 			Length:       1,
-			Frames: []frames.Frame{&frames.StreamFrame{
+			Frames: []wire.Frame{&wire.StreamFrame{
 				Data: []byte("foobar"),
 			}},
 			EncryptionLevel: protocol.EncryptionForwardSecure,
@@ -1251,7 +1251,7 @@ var _ = Describe("Session", func() {
 
 		It("sets the timer to the ack timer", func() {
 			rph := &mockReceivedPacketHandler{ackAlarm: time.Now().Add(10 * time.Millisecond)}
-			rph.nextAckFrame = &frames.AckFrame{LargestAcked: 0x1337}
+			rph.nextAckFrame = &wire.AckFrame{LargestAcked: 0x1337}
 			sess.receivedPacketHandler = rph
 			go sess.run()
 			defer sess.Close(nil)
@@ -1347,7 +1347,7 @@ var _ = Describe("Session", func() {
 		// this completely fills up the undecryptable packets queue and triggers the public reset timer
 		sendUndecryptablePackets := func() {
 			for i := 0; i < protocol.MaxUndecryptablePackets+1; i++ {
-				hdr := &PublicHeader{
+				hdr := &wire.PublicHeader{
 					PacketNumber: protocol.PacketNumber(i + 1),
 				}
 				sess.handlePacket(&receivedPacket{
@@ -1420,7 +1420,7 @@ var _ = Describe("Session", func() {
 
 		It("unqueues undecryptable packets for later decryption", func() {
 			sess.undecryptablePackets = []*receivedPacket{{
-				publicHeader: &PublicHeader{PacketNumber: protocol.PacketNumber(42)},
+				publicHeader: &wire.PublicHeader{PacketNumber: protocol.PacketNumber(42)},
 			}}
 			Expect(sess.receivedPackets).NotTo(Receive())
 			sess.tryDecryptingQueuedPackets()
@@ -1628,11 +1628,11 @@ var _ = Describe("Session", func() {
 				PacketNumber: 1,
 				Length:       1,
 			})
-			err := sess.handleFrames([]frames.Frame{&frames.AckFrame{
+			err := sess.handleFrames([]wire.Frame{&wire.AckFrame{
 				LargestAcked: 1,
 			}})
 			Expect(err).NotTo(HaveOccurred())
-			err = sess.handleFrames([]frames.Frame{&frames.AckFrame{
+			err = sess.handleFrames([]wire.Frame{&wire.AckFrame{
 				LargestAcked: 1,
 			}})
 			Expect(err).NotTo(HaveOccurred())
@@ -1646,7 +1646,7 @@ var _ = Describe("Session", func() {
 			frames := sess.getWindowUpdateFrames()
 			Expect(frames).To(HaveLen(1))
 			Expect(frames[0].StreamID).To(Equal(protocol.StreamID(1)))
-			Expect(frames[0].ByteOffset).To(Equal(protocol.ReceiveStreamFlowControlWindow * 2))
+			Expect(frames[0].ByteOffset).To(BeEquivalentTo(protocol.ReceiveStreamFlowControlWindow * 2))
 		})
 
 		It("gets connection level window updates", func() {
@@ -1657,7 +1657,7 @@ var _ = Describe("Session", func() {
 			frames := sess.getWindowUpdateFrames()
 			Expect(frames).To(HaveLen(1))
 			Expect(frames[0].StreamID).To(Equal(protocol.StreamID(0)))
-			Expect(frames[0].ByteOffset).To(Equal(protocol.ReceiveConnectionFlowControlWindow * 2))
+			Expect(frames[0].ByteOffset).To(BeEquivalentTo(protocol.ReceiveConnectionFlowControlWindow * 2))
 		})
 	})
 
@@ -1722,10 +1722,10 @@ var _ = Describe("Client Session", func() {
 	})
 
 	Context("receiving packets", func() {
-		var hdr *PublicHeader
+		var hdr *wire.PublicHeader
 
 		BeforeEach(func() {
-			hdr = &PublicHeader{PacketNumberLen: protocol.PacketNumberLen6}
+			hdr = &wire.PublicHeader{PacketNumberLen: protocol.PacketNumberLen6}
 			sess.unpacker = &mockUnpacker{}
 		})
 
diff --git a/stream.go b/stream.go
index ffadc183f..41c8e1054 100644
--- a/stream.go
+++ b/stream.go
@@ -8,10 +8,10 @@ import (
 	"sync"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/flowcontrol"
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/flowcontrol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 // A Stream assembles the data from StreamFrames and provides a super-convenient Read-Interface
@@ -289,7 +289,7 @@ func (s *stream) sentFin() {
 }
 
 // AddStreamFrame adds a new stream frame
-func (s *stream) AddStreamFrame(frame *frames.StreamFrame) error {
+func (s *stream) AddStreamFrame(frame *wire.StreamFrame) error {
 	maxOffset := frame.Offset + frame.DataLen()
 	err := s.flowControlManager.UpdateHighestReceived(s.streamID, maxOffset)
 	if err != nil {
@@ -353,7 +353,7 @@ func (s *stream) SetDeadline(t time.Time) error {
 
 // CloseRemote makes the stream receive a "virtual" FIN stream frame at a given offset
 func (s *stream) CloseRemote(offset protocol.ByteCount) {
-	s.AddStreamFrame(&frames.StreamFrame{FinBit: true, Offset: offset})
+	s.AddStreamFrame(&wire.StreamFrame{FinBit: true, Offset: offset})
 }
 
 // Cancel is called by session to indicate that an error occurred
diff --git a/stream_frame_sorter.go b/stream_frame_sorter.go
index 4a50150e2..e3a3a807a 100644
--- a/stream_frame_sorter.go
+++ b/stream_frame_sorter.go
@@ -3,13 +3,13 @@ package quic
 import (
 	"errors"
 
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 type streamFrameSorter struct {
-	queuedFrames map[protocol.ByteCount]*frames.StreamFrame
+	queuedFrames map[protocol.ByteCount]*wire.StreamFrame
 	readPosition protocol.ByteCount
 	gaps         *utils.ByteIntervalList
 }
@@ -23,13 +23,13 @@ var (
 func newStreamFrameSorter() *streamFrameSorter {
 	s := streamFrameSorter{
 		gaps:         utils.NewByteIntervalList(),
-		queuedFrames: make(map[protocol.ByteCount]*frames.StreamFrame),
+		queuedFrames: make(map[protocol.ByteCount]*wire.StreamFrame),
 	}
 	s.gaps.PushFront(utils.ByteInterval{Start: 0, End: protocol.MaxByteCount})
 	return &s
 }
 
-func (s *streamFrameSorter) Push(frame *frames.StreamFrame) error {
+func (s *streamFrameSorter) Push(frame *wire.StreamFrame) error {
 	if frame.DataLen() == 0 {
 		if frame.FinBit {
 			s.queuedFrames[frame.Offset] = frame
@@ -143,7 +143,7 @@ func (s *streamFrameSorter) Push(frame *frames.StreamFrame) error {
 	return nil
 }
 
-func (s *streamFrameSorter) Pop() *frames.StreamFrame {
+func (s *streamFrameSorter) Pop() *wire.StreamFrame {
 	frame := s.Head()
 	if frame != nil {
 		s.readPosition += frame.DataLen()
@@ -152,7 +152,7 @@ func (s *streamFrameSorter) Pop() *frames.StreamFrame {
 	return frame
 }
 
-func (s *streamFrameSorter) Head() *frames.StreamFrame {
+func (s *streamFrameSorter) Head() *wire.StreamFrame {
 	frame, ok := s.queuedFrames[s.readPosition]
 	if ok {
 		return frame
diff --git a/stream_frame_sorter_test.go b/stream_frame_sorter_test.go
index 398729af8..3980e568f 100644
--- a/stream_frame_sorter_test.go
+++ b/stream_frame_sorter_test.go
@@ -3,9 +3,9 @@ package quic
 import (
 	"bytes"
 
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -32,7 +32,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 	Context("Push", func() {
 		It("inserts and pops a single frame", func() {
-			f := &frames.StreamFrame{
+			f := &wire.StreamFrame{
 				Offset: 0,
 				Data:   []byte("foobar"),
 			}
@@ -44,11 +44,11 @@ var _ = Describe("StreamFrame sorter", func() {
 		})
 
 		It("inserts and pops two consecutive frame", func() {
-			f1 := &frames.StreamFrame{
+			f1 := &wire.StreamFrame{
 				Offset: 0,
 				Data:   []byte("foobar"),
 			}
-			f2 := &frames.StreamFrame{
+			f2 := &wire.StreamFrame{
 				Offset: 6,
 				Data:   []byte("foobar2"),
 			}
@@ -62,14 +62,14 @@ var _ = Describe("StreamFrame sorter", func() {
 		})
 
 		It("rejects empty frames", func() {
-			f := &frames.StreamFrame{}
+			f := &wire.StreamFrame{}
 			err := s.Push(f)
 			Expect(err).To(MatchError(errEmptyStreamData))
 		})
 
 		Context("FinBit handling", func() {
 			It("saves a FinBit frame at offset 0", func() {
-				f := &frames.StreamFrame{
+				f := &wire.StreamFrame{
 					Offset: 0,
 					FinBit: true,
 				}
@@ -79,13 +79,13 @@ var _ = Describe("StreamFrame sorter", func() {
 			})
 
 			It("sets the FinBit if a stream is closed after receiving some data", func() {
-				f1 := &frames.StreamFrame{
+				f1 := &wire.StreamFrame{
 					Offset: 0,
 					Data:   []byte("foobar"),
 				}
 				err := s.Push(f1)
 				Expect(err).ToNot(HaveOccurred())
-				f2 := &frames.StreamFrame{
+				f2 := &wire.StreamFrame{
 					Offset: 6,
 					FinBit: true,
 				}
@@ -98,7 +98,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 		Context("Gap handling", func() {
 			It("finds the first gap", func() {
-				f := &frames.StreamFrame{
+				f := &wire.StreamFrame{
 					Offset: 10,
 					Data:   []byte("foobar"),
 				}
@@ -111,7 +111,7 @@ var _ = Describe("StreamFrame sorter", func() {
 			})
 
 			It("correctly sets the first gap for a frame with offset 0", func() {
-				f := &frames.StreamFrame{
+				f := &wire.StreamFrame{
 					Offset: 0,
 					Data:   []byte("foobar"),
 				}
@@ -123,13 +123,13 @@ var _ = Describe("StreamFrame sorter", func() {
 			})
 
 			It("finds the two gaps", func() {
-				f1 := &frames.StreamFrame{
+				f1 := &wire.StreamFrame{
 					Offset: 10,
 					Data:   []byte("foobar"),
 				}
 				err := s.Push(f1)
 				Expect(err).ToNot(HaveOccurred())
-				f2 := &frames.StreamFrame{
+				f2 := &wire.StreamFrame{
 					Offset: 20,
 					Data:   []byte("foobar"),
 				}
@@ -143,13 +143,13 @@ var _ = Describe("StreamFrame sorter", func() {
 			})
 
 			It("finds the two gaps in reverse order", func() {
-				f1 := &frames.StreamFrame{
+				f1 := &wire.StreamFrame{
 					Offset: 20,
 					Data:   []byte("foobar"),
 				}
 				err := s.Push(f1)
 				Expect(err).ToNot(HaveOccurred())
-				f2 := &frames.StreamFrame{
+				f2 := &wire.StreamFrame{
 					Offset: 10,
 					Data:   []byte("foobar"),
 				}
@@ -163,13 +163,13 @@ var _ = Describe("StreamFrame sorter", func() {
 			})
 
 			It("shrinks a gap when it is partially filled", func() {
-				f1 := &frames.StreamFrame{
+				f1 := &wire.StreamFrame{
 					Offset: 10,
 					Data:   []byte("test"),
 				}
 				err := s.Push(f1)
 				Expect(err).ToNot(HaveOccurred())
-				f2 := &frames.StreamFrame{
+				f2 := &wire.StreamFrame{
 					Offset: 4,
 					Data:   []byte("foobar"),
 				}
@@ -182,13 +182,13 @@ var _ = Describe("StreamFrame sorter", func() {
 			})
 
 			It("deletes a gap at the beginning, when it is filled", func() {
-				f1 := &frames.StreamFrame{
+				f1 := &wire.StreamFrame{
 					Offset: 6,
 					Data:   []byte("test"),
 				}
 				err := s.Push(f1)
 				Expect(err).ToNot(HaveOccurred())
-				f2 := &frames.StreamFrame{
+				f2 := &wire.StreamFrame{
 					Offset: 0,
 					Data:   []byte("foobar"),
 				}
@@ -200,19 +200,19 @@ var _ = Describe("StreamFrame sorter", func() {
 			})
 
 			It("deletes a gap in the middle, when it is filled", func() {
-				f1 := &frames.StreamFrame{
+				f1 := &wire.StreamFrame{
 					Offset: 0,
 					Data:   []byte("test"),
 				}
 				err := s.Push(f1)
 				Expect(err).ToNot(HaveOccurred())
-				f2 := &frames.StreamFrame{
+				f2 := &wire.StreamFrame{
 					Offset: 10,
 					Data:   []byte("test2"),
 				}
 				err = s.Push(f2)
 				Expect(err).ToNot(HaveOccurred())
-				f3 := &frames.StreamFrame{
+				f3 := &wire.StreamFrame{
 					Offset: 4,
 					Data:   []byte("foobar"),
 				}
@@ -225,13 +225,13 @@ var _ = Describe("StreamFrame sorter", func() {
 			})
 
 			It("splits a gap into two", func() {
-				f1 := &frames.StreamFrame{
+				f1 := &wire.StreamFrame{
 					Offset: 100,
 					Data:   []byte("test"),
 				}
 				err := s.Push(f1)
 				Expect(err).ToNot(HaveOccurred())
-				f2 := &frames.StreamFrame{
+				f2 := &wire.StreamFrame{
 					Offset: 50,
 					Data:   []byte("foobar"),
 				}
@@ -248,11 +248,11 @@ var _ = Describe("StreamFrame sorter", func() {
 			Context("Overlapping Stream Data detection", func() {
 				// create gaps: 0-5, 10-15, 20-25, 30-inf
 				BeforeEach(func() {
-					err := s.Push(&frames.StreamFrame{Offset: 5, Data: []byte("12345")})
+					err := s.Push(&wire.StreamFrame{Offset: 5, Data: []byte("12345")})
 					Expect(err).ToNot(HaveOccurred())
-					err = s.Push(&frames.StreamFrame{Offset: 15, Data: []byte("12345")})
+					err = s.Push(&wire.StreamFrame{Offset: 15, Data: []byte("12345")})
 					Expect(err).ToNot(HaveOccurred())
-					err = s.Push(&frames.StreamFrame{Offset: 25, Data: []byte("12345")})
+					err = s.Push(&wire.StreamFrame{Offset: 25, Data: []byte("12345")})
 					Expect(err).ToNot(HaveOccurred())
 					checkGaps([]utils.ByteInterval{
 						{Start: 0, End: 5},
@@ -263,7 +263,7 @@ var _ = Describe("StreamFrame sorter", func() {
 				})
 
 				It("cuts a frame with offset 0 that overlaps at the end", func() {
-					f := &frames.StreamFrame{
+					f := &wire.StreamFrame{
 						Offset: 0,
 						Data:   []byte("foobar"),
 					}
@@ -281,7 +281,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("cuts a frame that overlaps at the end", func() {
 					// 4 to 7
-					f := &frames.StreamFrame{
+					f := &wire.StreamFrame{
 						Offset: 4,
 						Data:   []byte("foo"),
 					}
@@ -300,7 +300,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("cuts a frame that completely fills a gap, but overlaps at the end", func() {
 					// 10 to 16
-					f := &frames.StreamFrame{
+					f := &wire.StreamFrame{
 						Offset: 10,
 						Data:   []byte("foobar"),
 					}
@@ -318,7 +318,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("cuts a frame that overlaps at the beginning", func() {
 					// 8 to 14
-					f := &frames.StreamFrame{
+					f := &wire.StreamFrame{
 						Offset: 8,
 						Data:   []byte("foobar"),
 					}
@@ -338,7 +338,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("processes a frame that overlaps at the beginning and at the end, starting in a gap", func() {
 					// 2 to 12
-					f := &frames.StreamFrame{
+					f := &wire.StreamFrame{
 						Offset: 2,
 						Data:   []byte("1234567890"),
 					}
@@ -357,7 +357,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("processes a frame that overlaps at the beginning and at the end, starting in a gap, ending in data", func() {
 					// 2 to 17
-					f := &frames.StreamFrame{
+					f := &wire.StreamFrame{
 						Offset: 2,
 						Data:   []byte("123456789012345"),
 					}
@@ -376,7 +376,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("processes a frame that overlaps at the beginning and at the end, starting in a gap, ending in data", func() {
 					// 5 to 22
-					f := &frames.StreamFrame{
+					f := &wire.StreamFrame{
 						Offset: 5,
 						Data:   []byte("12345678901234567"),
 					}
@@ -394,7 +394,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("processes a frame that closes multiple gaps", func() {
 					// 2 to 27
-					f := &frames.StreamFrame{
+					f := &wire.StreamFrame{
 						Offset: 2,
 						Data:   bytes.Repeat([]byte{'e'}, 25),
 					}
@@ -414,7 +414,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("processes a frame that closes multiple gaps", func() {
 					// 5 to 27
-					f := &frames.StreamFrame{
+					f := &wire.StreamFrame{
 						Offset: 5,
 						Data:   bytes.Repeat([]byte{'d'}, 22),
 					}
@@ -434,7 +434,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("processes a frame that covers multiple gaps and ends at the end of a gap", func() {
 					// 1 to 15
-					f := &frames.StreamFrame{
+					f := &wire.StreamFrame{
 						Offset: 1,
 						Data:   bytes.Repeat([]byte{'f'}, 14),
 					}
@@ -453,7 +453,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("processes a frame that closes all gaps (except for the last one)", func() {
 					// 0 to 32
-					f := &frames.StreamFrame{
+					f := &wire.StreamFrame{
 						Offset: 0,
 						Data:   bytes.Repeat([]byte{'f'}, 32),
 					}
@@ -469,7 +469,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("cuts a frame that overlaps at the beginning and at the end, starting in data already received", func() {
 					// 8 to 17
-					f := &frames.StreamFrame{
+					f := &wire.StreamFrame{
 						Offset: 8,
 						Data:   []byte("123456789"),
 					}
@@ -488,7 +488,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("cuts a frame that completely covers two gaps", func() {
 					// 10 to 20
-					f := &frames.StreamFrame{
+					f := &wire.StreamFrame{
 						Offset: 10,
 						Data:   []byte("1234567890"),
 					}
@@ -513,9 +513,9 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				BeforeEach(func() {
 					// create gaps: 5-10, 15-inf
-					err := s.Push(&frames.StreamFrame{Offset: 0, Data: []byte("12345")})
+					err := s.Push(&wire.StreamFrame{Offset: 0, Data: []byte("12345")})
 					Expect(err).ToNot(HaveOccurred())
-					err = s.Push(&frames.StreamFrame{Offset: 10, Data: []byte("12345")})
+					err = s.Push(&wire.StreamFrame{Offset: 10, Data: []byte("12345")})
 					Expect(err).ToNot(HaveOccurred())
 					checkGaps(expectedGaps)
 				})
@@ -526,21 +526,21 @@ var _ = Describe("StreamFrame sorter", func() {
 				})
 
 				It("does not modify data when receiving a duplicate", func() {
-					err := s.Push(&frames.StreamFrame{Offset: 0, Data: []byte("fffff")})
+					err := s.Push(&wire.StreamFrame{Offset: 0, Data: []byte("fffff")})
 					Expect(err).To(MatchError(errDuplicateStreamData))
 					Expect(s.queuedFrames[0].Data).ToNot(Equal([]byte("fffff")))
 				})
 
 				It("detects a duplicate frame that is smaller than the original, starting at the beginning", func() {
 					// 10 to 12
-					err := s.Push(&frames.StreamFrame{Offset: 10, Data: []byte("12")})
+					err := s.Push(&wire.StreamFrame{Offset: 10, Data: []byte("12")})
 					Expect(err).To(MatchError(errDuplicateStreamData))
 					Expect(s.queuedFrames[10].Data).To(HaveLen(5))
 				})
 
 				It("detects a duplicate frame that is smaller than the original, somewhere in the middle", func() {
 					// 1 to 4
-					err := s.Push(&frames.StreamFrame{Offset: 1, Data: []byte("123")})
+					err := s.Push(&wire.StreamFrame{Offset: 1, Data: []byte("123")})
 					Expect(err).To(MatchError(errDuplicateStreamData))
 					Expect(s.queuedFrames[0].Data).To(HaveLen(5))
 					Expect(s.queuedFrames).ToNot(HaveKey(protocol.ByteCount(1)))
@@ -548,7 +548,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("detects a duplicate frame that is smaller than the original, somewhere in the middle in the last block", func() {
 					// 11 to 14
-					err := s.Push(&frames.StreamFrame{Offset: 11, Data: []byte("123")})
+					err := s.Push(&wire.StreamFrame{Offset: 11, Data: []byte("123")})
 					Expect(err).To(MatchError(errDuplicateStreamData))
 					Expect(s.queuedFrames[10].Data).To(HaveLen(5))
 					Expect(s.queuedFrames).ToNot(HaveKey(protocol.ByteCount(11)))
@@ -556,7 +556,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("detects a duplicate frame that is smaller than the original, with aligned end in the last block", func() {
 					// 11 to 14
-					err := s.Push(&frames.StreamFrame{Offset: 11, Data: []byte("1234")})
+					err := s.Push(&wire.StreamFrame{Offset: 11, Data: []byte("1234")})
 					Expect(err).To(MatchError(errDuplicateStreamData))
 					Expect(s.queuedFrames[10].Data).To(HaveLen(5))
 					Expect(s.queuedFrames).ToNot(HaveKey(protocol.ByteCount(11)))
@@ -564,7 +564,7 @@ var _ = Describe("StreamFrame sorter", func() {
 
 				It("detects a duplicate frame that is smaller than the original, with aligned end", func() {
 					// 3 to 5
-					err := s.Push(&frames.StreamFrame{Offset: 3, Data: []byte("12")})
+					err := s.Push(&wire.StreamFrame{Offset: 3, Data: []byte("12")})
 					Expect(err).To(MatchError(errDuplicateStreamData))
 					Expect(s.queuedFrames[0].Data).To(HaveLen(5))
 					Expect(s.queuedFrames).ToNot(HaveKey(protocol.ByteCount(3)))
@@ -574,7 +574,7 @@ var _ = Describe("StreamFrame sorter", func() {
 			Context("DoS protection", func() {
 				It("errors when too many gaps are created", func() {
 					for i := 0; i < protocol.MaxStreamFrameSorterGaps; i++ {
-						f := &frames.StreamFrame{
+						f := &wire.StreamFrame{
 							Data:   []byte("foobar"),
 							Offset: protocol.ByteCount(i * 7),
 						}
@@ -582,7 +582,7 @@ var _ = Describe("StreamFrame sorter", func() {
 						Expect(err).ToNot(HaveOccurred())
 					}
 					Expect(s.gaps.Len()).To(Equal(protocol.MaxStreamFrameSorterGaps))
-					f := &frames.StreamFrame{
+					f := &wire.StreamFrame{
 						Data:   []byte("foobar"),
 						Offset: protocol.ByteCount(protocol.MaxStreamFrameSorterGaps*7) + 100,
 					}
diff --git a/stream_framer.go b/stream_framer.go
index 20f82e3e2..d5916c211 100644
--- a/stream_framer.go
+++ b/stream_framer.go
@@ -1,10 +1,10 @@
 package quic
 
 import (
-	"github.com/lucas-clemente/quic-go/flowcontrol"
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/flowcontrol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 type streamFramer struct {
@@ -12,8 +12,8 @@ type streamFramer struct {
 
 	flowControlManager flowcontrol.FlowControlManager
 
-	retransmissionQueue []*frames.StreamFrame
-	blockedFrameQueue   []*frames.BlockedFrame
+	retransmissionQueue []*wire.StreamFrame
+	blockedFrameQueue   []*wire.BlockedFrame
 }
 
 func newStreamFramer(streamsMap *streamsMap, flowControlManager flowcontrol.FlowControlManager) *streamFramer {
@@ -23,16 +23,16 @@ func newStreamFramer(streamsMap *streamsMap, flowControlManager flowcontrol.Flow
 	}
 }
 
-func (f *streamFramer) AddFrameForRetransmission(frame *frames.StreamFrame) {
+func (f *streamFramer) AddFrameForRetransmission(frame *wire.StreamFrame) {
 	f.retransmissionQueue = append(f.retransmissionQueue, frame)
 }
 
-func (f *streamFramer) PopStreamFrames(maxLen protocol.ByteCount) []*frames.StreamFrame {
+func (f *streamFramer) PopStreamFrames(maxLen protocol.ByteCount) []*wire.StreamFrame {
 	fs, currentLen := f.maybePopFramesForRetransmission(maxLen)
 	return append(fs, f.maybePopNormalFrames(maxLen-currentLen)...)
 }
 
-func (f *streamFramer) PopBlockedFrame() *frames.BlockedFrame {
+func (f *streamFramer) PopBlockedFrame() *wire.BlockedFrame {
 	if len(f.blockedFrameQueue) == 0 {
 		return nil
 	}
@@ -53,12 +53,12 @@ func (f *streamFramer) HasCryptoStreamFrame() bool {
 
 // TODO(lclemente): This is somewhat duplicate with the normal path for generating frames.
 // TODO(#657): Flow control
-func (f *streamFramer) PopCryptoStreamFrame(maxLen protocol.ByteCount) *frames.StreamFrame {
+func (f *streamFramer) PopCryptoStreamFrame(maxLen protocol.ByteCount) *wire.StreamFrame {
 	if !f.HasCryptoStreamFrame() {
 		return nil
 	}
 	cs, _ := f.streamsMap.GetOrOpenStream(1)
-	frame := &frames.StreamFrame{
+	frame := &wire.StreamFrame{
 		StreamID: 1,
 		Offset:   cs.writeOffset,
 	}
@@ -67,7 +67,7 @@ func (f *streamFramer) PopCryptoStreamFrame(maxLen protocol.ByteCount) *frames.S
 	return frame
 }
 
-func (f *streamFramer) maybePopFramesForRetransmission(maxLen protocol.ByteCount) (res []*frames.StreamFrame, currentLen protocol.ByteCount) {
+func (f *streamFramer) maybePopFramesForRetransmission(maxLen protocol.ByteCount) (res []*wire.StreamFrame, currentLen protocol.ByteCount) {
 	for len(f.retransmissionQueue) > 0 {
 		frame := f.retransmissionQueue[0]
 		frame.DataLenPresent = true
@@ -93,8 +93,8 @@ func (f *streamFramer) maybePopFramesForRetransmission(maxLen protocol.ByteCount
 	return
 }
 
-func (f *streamFramer) maybePopNormalFrames(maxBytes protocol.ByteCount) (res []*frames.StreamFrame) {
-	frame := &frames.StreamFrame{DataLenPresent: true}
+func (f *streamFramer) maybePopNormalFrames(maxBytes protocol.ByteCount) (res []*wire.StreamFrame) {
+	frame := &wire.StreamFrame{DataLenPresent: true}
 	var currentLen protocol.ByteCount
 
 	fn := func(s *stream) (bool, error) {
@@ -146,10 +146,10 @@ func (f *streamFramer) maybePopNormalFrames(maxBytes protocol.ByteCount) (res []
 		// Finally, check if we are now FC blocked and should queue a BLOCKED frame
 		if f.flowControlManager.RemainingConnectionWindowSize() == 0 {
 			// We are now connection-level FC blocked
-			f.blockedFrameQueue = append(f.blockedFrameQueue, &frames.BlockedFrame{StreamID: 0})
+			f.blockedFrameQueue = append(f.blockedFrameQueue, &wire.BlockedFrame{StreamID: 0})
 		} else if !frame.FinBit && sendWindowSize-frame.DataLen() == 0 {
 			// We are now stream-level FC blocked
-			f.blockedFrameQueue = append(f.blockedFrameQueue, &frames.BlockedFrame{StreamID: s.StreamID()})
+			f.blockedFrameQueue = append(f.blockedFrameQueue, &wire.BlockedFrame{StreamID: s.StreamID()})
 		}
 
 		res = append(res, frame)
@@ -159,7 +159,7 @@ func (f *streamFramer) maybePopNormalFrames(maxBytes protocol.ByteCount) (res []
 			return false, nil
 		}
 
-		frame = &frames.StreamFrame{DataLenPresent: true}
+		frame = &wire.StreamFrame{DataLenPresent: true}
 		return true, nil
 	}
 
@@ -169,7 +169,7 @@ func (f *streamFramer) maybePopNormalFrames(maxBytes protocol.ByteCount) (res []
 }
 
 // maybeSplitOffFrame removes the first n bytes and returns them as a separate frame. If n >= len(frame), nil is returned and nothing is modified.
-func maybeSplitOffFrame(frame *frames.StreamFrame, n protocol.ByteCount) *frames.StreamFrame {
+func maybeSplitOffFrame(frame *wire.StreamFrame, n protocol.ByteCount) *wire.StreamFrame {
 	if n >= frame.DataLen() {
 		return nil
 	}
@@ -179,7 +179,7 @@ func maybeSplitOffFrame(frame *frames.StreamFrame, n protocol.ByteCount) *frames
 		frame.Offset += n
 	}()
 
-	return &frames.StreamFrame{
+	return &wire.StreamFrame{
 		FinBit:         false,
 		StreamID:       frame.StreamID,
 		Offset:         frame.Offset,
diff --git a/stream_framer_test.go b/stream_framer_test.go
index 506a544ab..a93d068ab 100644
--- a/stream_framer_test.go
+++ b/stream_framer_test.go
@@ -3,9 +3,9 @@ package quic
 import (
 	"bytes"
 
-	"github.com/lucas-clemente/quic-go/frames"
 	"github.com/lucas-clemente/quic-go/internal/mocks/mocks_fc"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -17,7 +17,7 @@ var _ = Describe("Stream Framer", func() {
 	)
 
 	var (
-		retransmittedFrame1, retransmittedFrame2 *frames.StreamFrame
+		retransmittedFrame1, retransmittedFrame2 *wire.StreamFrame
 		framer                                   *streamFramer
 		streamsMap                               *streamsMap
 		stream1, stream2                         *stream
@@ -25,11 +25,11 @@ var _ = Describe("Stream Framer", func() {
 	)
 
 	BeforeEach(func() {
-		retransmittedFrame1 = &frames.StreamFrame{
+		retransmittedFrame1 = &wire.StreamFrame{
 			StreamID: 5,
 			Data:     []byte{0x13, 0x37},
 		}
-		retransmittedFrame2 = &frames.StreamFrame{
+		retransmittedFrame2 = &wire.StreamFrame{
 			StreamID: 6,
 			Data:     []byte{0xDE, 0xCA, 0xFB, 0xAD},
 		}
@@ -165,7 +165,7 @@ var _ = Describe("Stream Framer", func() {
 
 		Context("splitting of frames", func() {
 			It("splits off nothing", func() {
-				f := &frames.StreamFrame{
+				f := &wire.StreamFrame{
 					StreamID: 1,
 					Data:     []byte("bar"),
 					Offset:   3,
@@ -176,7 +176,7 @@ var _ = Describe("Stream Framer", func() {
 			})
 
 			It("splits off initial frame", func() {
-				f := &frames.StreamFrame{
+				f := &wire.StreamFrame{
 					StreamID:       1,
 					Data:           []byte("foobar"),
 					DataLenPresent: true,
@@ -210,7 +210,7 @@ var _ = Describe("Stream Framer", func() {
 
 			It("never returns an empty stream frame", func() {
 				// this one frame will be split off from again and again in this test. Therefore, it has to be large enough (checked again at the end)
-				origFrame := &frames.StreamFrame{
+				origFrame := &wire.StreamFrame{
 					StreamID: 5,
 					Offset:   1,
 					FinBit:   false,
diff --git a/stream_test.go b/stream_test.go
index d347881d4..ad73469ff 100644
--- a/stream_test.go
+++ b/stream_test.go
@@ -9,9 +9,10 @@ import (
 
 	"os"
 
-	"github.com/lucas-clemente/quic-go/frames"
 	"github.com/lucas-clemente/quic-go/internal/mocks/mocks_fc"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
+
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 	"github.com/onsi/gomega/gbytes"
@@ -78,7 +79,7 @@ var _ = Describe("Stream", func() {
 		It("reads a single StreamFrame", func() {
 			mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
 			mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(4))
-			frame := frames.StreamFrame{
+			frame := wire.StreamFrame{
 				Offset: 0,
 				Data:   []byte{0xDE, 0xAD, 0xBE, 0xEF},
 			}
@@ -95,7 +96,7 @@ var _ = Describe("Stream", func() {
 			mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
 			mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(2))
 			mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(2))
-			frame := frames.StreamFrame{
+			frame := wire.StreamFrame{
 				Offset: 0,
 				Data:   []byte{0xDE, 0xAD, 0xBE, 0xEF},
 			}
@@ -116,11 +117,11 @@ var _ = Describe("Stream", func() {
 			mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(2))
 			mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
 			mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(2)).Times(2)
-			frame1 := frames.StreamFrame{
+			frame1 := wire.StreamFrame{
 				Offset: 0,
 				Data:   []byte{0xDE, 0xAD},
 			}
-			frame2 := frames.StreamFrame{
+			frame2 := wire.StreamFrame{
 				Offset: 2,
 				Data:   []byte{0xBE, 0xEF},
 			}
@@ -139,11 +140,11 @@ var _ = Describe("Stream", func() {
 			mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(2))
 			mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
 			mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(2)).Times(2)
-			frame1 := frames.StreamFrame{
+			frame1 := wire.StreamFrame{
 				Offset: 0,
 				Data:   []byte{0xDE, 0xAD},
 			}
-			frame2 := frames.StreamFrame{
+			frame2 := wire.StreamFrame{
 				Offset: 2,
 				Data:   []byte{0xBE, 0xEF},
 			}
@@ -163,7 +164,7 @@ var _ = Describe("Stream", func() {
 			mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(2))
 			go func() {
 				defer GinkgoRecover()
-				frame := frames.StreamFrame{Data: []byte{0xDE, 0xAD}}
+				frame := wire.StreamFrame{Data: []byte{0xDE, 0xAD}}
 				time.Sleep(10 * time.Millisecond)
 				err := str.AddStreamFrame(&frame)
 				Expect(err).ToNot(HaveOccurred())
@@ -178,11 +179,11 @@ var _ = Describe("Stream", func() {
 			mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(2))
 			mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
 			mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(2)).Times(2)
-			frame1 := frames.StreamFrame{
+			frame1 := wire.StreamFrame{
 				Offset: 2,
 				Data:   []byte{0xBE, 0xEF},
 			}
-			frame2 := frames.StreamFrame{
+			frame2 := wire.StreamFrame{
 				Offset: 0,
 				Data:   []byte{0xDE, 0xAD},
 			}
@@ -202,15 +203,15 @@ var _ = Describe("Stream", func() {
 			mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(2))
 			mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
 			mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(2)).Times(2)
-			frame1 := frames.StreamFrame{
+			frame1 := wire.StreamFrame{
 				Offset: 0,
 				Data:   []byte{0xDE, 0xAD},
 			}
-			frame2 := frames.StreamFrame{
+			frame2 := wire.StreamFrame{
 				Offset: 0,
 				Data:   []byte{0x13, 0x37},
 			}
-			frame3 := frames.StreamFrame{
+			frame3 := wire.StreamFrame{
 				Offset: 2,
 				Data:   []byte{0xBE, 0xEF},
 			}
@@ -232,11 +233,11 @@ var _ = Describe("Stream", func() {
 			mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(6))
 			mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(2))
 			mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(4))
-			frame1 := frames.StreamFrame{
+			frame1 := wire.StreamFrame{
 				Offset: 0,
 				Data:   []byte("foob"),
 			}
-			frame2 := frames.StreamFrame{
+			frame2 := wire.StreamFrame{
 				Offset: 2,
 				Data:   []byte("obar"),
 			}
@@ -254,7 +255,7 @@ var _ = Describe("Stream", func() {
 		It("calls onData", func() {
 			mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
 			mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(4))
-			frame := frames.StreamFrame{
+			frame := wire.StreamFrame{
 				Offset: 0,
 				Data:   []byte{0xDE, 0xAD, 0xBE, 0xEF},
 			}
@@ -273,7 +274,7 @@ var _ = Describe("Stream", func() {
 
 			It("returns an error when Read is called after the deadline", func() {
 				mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(6)).AnyTimes()
-				f := &frames.StreamFrame{Data: []byte("foobar")}
+				f := &wire.StreamFrame{Data: []byte("foobar")}
 				err := str.AddStreamFrame(f)
 				Expect(err).ToNot(HaveOccurred())
 				str.SetReadDeadline(time.Now().Add(-time.Second))
@@ -332,7 +333,7 @@ var _ = Describe("Stream", func() {
 
 			It("sets a read deadline, when SetDeadline is called", func() {
 				mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(6)).AnyTimes()
-				f := &frames.StreamFrame{Data: []byte("foobar")}
+				f := &wire.StreamFrame{Data: []byte("foobar")}
 				err := str.AddStreamFrame(f)
 				Expect(err).ToNot(HaveOccurred())
 				str.SetDeadline(time.Now().Add(-time.Second))
@@ -348,7 +349,7 @@ var _ = Describe("Stream", func() {
 				It("returns EOFs", func() {
 					mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
 					mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(4))
-					frame := frames.StreamFrame{
+					frame := wire.StreamFrame{
 						Offset: 0,
 						Data:   []byte{0xDE, 0xAD, 0xBE, 0xEF},
 						FinBit: true,
@@ -368,12 +369,12 @@ var _ = Describe("Stream", func() {
 					mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(2))
 					mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
 					mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(2)).Times(2)
-					frame1 := frames.StreamFrame{
+					frame1 := wire.StreamFrame{
 						Offset: 2,
 						Data:   []byte{0xBE, 0xEF},
 						FinBit: true,
 					}
-					frame2 := frames.StreamFrame{
+					frame2 := wire.StreamFrame{
 						Offset: 0,
 						Data:   []byte{0xDE, 0xAD},
 					}
@@ -394,7 +395,7 @@ var _ = Describe("Stream", func() {
 				It("returns EOFs with partial read", func() {
 					mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(2))
 					mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(2))
-					frame := frames.StreamFrame{
+					frame := wire.StreamFrame{
 						Offset: 0,
 						Data:   []byte{0xDE, 0xAD},
 						FinBit: true,
@@ -411,7 +412,7 @@ var _ = Describe("Stream", func() {
 				It("handles immediate FINs", func() {
 					mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(0))
 					mockFcm.EXPECT().AddBytesRead(streamID, protocol.ByteCount(0))
-					frame := frames.StreamFrame{
+					frame := wire.StreamFrame{
 						Offset: 0,
 						Data:   []byte{},
 						FinBit: true,
@@ -484,7 +485,7 @@ var _ = Describe("Stream", func() {
 		Context("reset by the peer", func() {
 			It("continues reading after receiving a remote error", func() {
 				mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
-				frame := frames.StreamFrame{
+				frame := wire.StreamFrame{
 					Offset: 0,
 					Data:   []byte{0xDE, 0xAD, 0xBE, 0xEF},
 				}
@@ -499,7 +500,7 @@ var _ = Describe("Stream", func() {
 			It("reads a delayed StreamFrame that arrives after receiving a remote error", func() {
 				mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
 				str.RegisterRemoteError(testErr)
-				frame := frames.StreamFrame{
+				frame := wire.StreamFrame{
 					Offset: 0,
 					Data:   []byte{0xDE, 0xAD, 0xBE, 0xEF},
 				}
@@ -513,7 +514,7 @@ var _ = Describe("Stream", func() {
 
 			It("returns the error if reading past the offset of the frame received", func() {
 				mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
-				frame := frames.StreamFrame{
+				frame := wire.StreamFrame{
 					Offset: 0,
 					Data:   []byte{0xDE, 0xAD, 0xBE, 0xEF},
 				}
@@ -528,7 +529,7 @@ var _ = Describe("Stream", func() {
 
 			It("returns an EOF when reading past the offset, if the stream received a finbit", func() {
 				mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
-				frame := frames.StreamFrame{
+				frame := wire.StreamFrame{
 					Offset: 0,
 					Data:   []byte{0xDE, 0xAD, 0xBE, 0xEF},
 					FinBit: true,
@@ -544,7 +545,7 @@ var _ = Describe("Stream", func() {
 
 			It("continues reading in small chunks after receiving a remote error", func() {
 				mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
-				frame := frames.StreamFrame{
+				frame := wire.StreamFrame{
 					Offset: 0,
 					Data:   []byte{0xDE, 0xAD, 0xBE, 0xEF},
 					FinBit: true,
@@ -565,7 +566,7 @@ var _ = Describe("Stream", func() {
 			It("doesn't inform the flow controller about bytes read after receiving the remote error", func() {
 				mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(4))
 				// No AddBytesRead()
-				frame := frames.StreamFrame{
+				frame := wire.StreamFrame{
 					Offset:   0,
 					StreamID: 5,
 					Data:     []byte{0xDE, 0xAD, 0xBE, 0xEF},
@@ -685,7 +686,7 @@ var _ = Describe("Stream", func() {
 
 			It("doesn't allow further reads", func() {
 				mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(6))
-				str.AddStreamFrame(&frames.StreamFrame{
+				str.AddStreamFrame(&wire.StreamFrame{
 					Data: []byte("foobar"),
 				})
 				str.Reset(testErr)
@@ -946,7 +947,7 @@ var _ = Describe("Stream", func() {
 	It("errors when a StreamFrames causes a flow control violation", func() {
 		testErr := errors.New("flow control violation")
 		mockFcm.EXPECT().UpdateHighestReceived(streamID, protocol.ByteCount(8)).Return(testErr)
-		frame := frames.StreamFrame{
+		frame := wire.StreamFrame{
 			Offset: 2,
 			Data:   []byte("foobar"),
 		}
@@ -958,7 +959,7 @@ var _ = Describe("Stream", func() {
 		testErr := errors.New("testErr")
 
 		finishReading := func() {
-			err := str.AddStreamFrame(&frames.StreamFrame{FinBit: true})
+			err := str.AddStreamFrame(&wire.StreamFrame{FinBit: true})
 			Expect(err).ToNot(HaveOccurred())
 			b := make([]byte, 100)
 			_, err = strWithTimeout.Read(b)
diff --git a/streams_map.go b/streams_map.go
index 74be17e08..6b0eba8d1 100644
--- a/streams_map.go
+++ b/streams_map.go
@@ -6,7 +6,7 @@ import (
 	"sync"
 
 	"github.com/lucas-clemente/quic-go/handshake"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
diff --git a/streams_map_test.go b/streams_map_test.go
index db6eceded..3c7f02fb4 100644
--- a/streams_map_test.go
+++ b/streams_map_test.go
@@ -4,7 +4,7 @@ import (
 	"errors"
 
 	"github.com/lucas-clemente/quic-go/internal/mocks"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"