bump go.mod version to Go 1.23, run 1.23 and 1.24 on CI (#4880)

.clusterfuzzlite/Dockerfile

@@ -3,7 +3,7 @@ FROM gcr.io/oss-fuzz-base/base-builder-go:v1
 ARG TARGETPLATFORM
 RUN echo "TARGETPLATFORM: ${TARGETPLATFORM}"
 
-ENV GOVERSION=1.23.0
+ENV GOVERSION=1.24.0
 
 RUN platform=$(echo ${TARGETPLATFORM} | tr '/' '-') && \
   filename="go${GOVERSION}.${platform}.tar.gz" && \

.github/workflows/cross-compile.yml

@@ -4,7 +4,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go: [ "1.22.x", "1.23.x" ]
+        go: [ "1.23.x", "1.24.x" ]
     runs-on: ${{ fromJSON(vars['CROSS_COMPILE_RUNNER_UBUNTU'] || '"ubuntu-latest"') }}
     name: "Cross Compilation (Go ${{matrix.go}})"
     timeout-minutes: 30

.github/workflows/integration.yml

@@ -6,21 +6,21 @@ jobs:
       fail-fast: false
       matrix:
         os: [ "ubuntu" ]
-        go: [ "1.22.x", "1.23.x" ]
+        go: [ "1.23.x", "1.24.x" ]
         race: [ false ]
         use32bit: [ false ]
         include:
           - os: "ubuntu"
-            go: "1.23.x"
+            go: "1.24.x"
             race: true
           - os: "ubuntu"
-            go: "1.23.x"
+            go: "1.24.x"
             use32bit: true
           - os: "windows"
-            go: "1.23.x"
+            go: "1.24.x"
             race: false
           - os: "macos"
-            go: "1.23.x"
+            go: "1.24.x"
             race: false
     runs-on: ${{ fromJSON(vars[format('INTEGRATION_RUNNER_{0}', matrix.os)] || format('"{0}-latest"', matrix.os)) }}
     timeout-minutes: 30

.github/workflows/lint.yml

@@ -8,7 +8,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-go@v5
         with:
-          go-version: "1.23.x"
+          go-version: "1.24.x"
       - name: Check that no non-test files import Ginkgo or Gomega
         run: .github/workflows/no_ginkgo.sh
       - name: Check for //go:build ignore in .go files
@@ -39,7 +39,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go: [  "1.22.x", "1.23.x" ]
+        go: [  "1.23.x", "1.24.x" ]
     env:
       GOLANGCI_LINT_VERSION: v1.64.4
     name: golangci-lint (Go ${{ matrix.go }})

.github/workflows/unit.yml

@@ -7,7 +7,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ "ubuntu", "windows", "macos" ]
-        go: [ "1.22.x", "1.23.x" ]
+        go: [ "1.23.x", "1.24.x" ]
     runs-on: ${{ fromJSON(vars[format('UNIT_RUNNER_{0}', matrix.os)] || format('"{0}-latest"', matrix.os)) }}
     name: Unit tests (${{ matrix.os}}, Go ${{ matrix.go }})
     timeout-minutes: 30

go.mod

@@ -1,6 +1,6 @@
 module github.com/quic-go/quic-go
 
-go 1.22
+go 1.23
 
 require (
 	github.com/francoispqt/gojay v1.2.13

integrationtests/gomodvendor/go.mod

@@ -1,8 +1,8 @@
 module test
 
-go 1.22
+go 1.23
 
-toolchain go1.22.4
+toolchain go1.23.4
 
 // The version doesn't matter here, as we're replacing it with the currently checked out code anyway.
 require github.com/quic-go/quic-go v0.21.0

internal/handshake/hkdf.go

@@ -8,8 +8,6 @@ import (
 )
 
 // hkdfExpandLabel HKDF expands a label as defined in RFC 8446, section 7.1.
-// Since this implementation avoids using a cryptobyte.Builder, it is about 15% faster than the
-// hkdfExpandLabel in the standard library.
 func hkdfExpandLabel(hash crypto.Hash, secret, context []byte, label string, length int) []byte {
 	b := make([]byte, 3, 3+6+len(label)+1+len(context))
 	binary.BigEndian.PutUint16(b, uint16(length))

internal/handshake/hkdf_test.go

@@ -3,15 +3,16 @@ package handshake
 import (
 	"crypto"
 	"crypto/cipher"
+	"crypto/rand"
 	"crypto/tls"
 	"testing"
 	"unsafe"
 
-	"golang.org/x/exp/rand"
-
 	"github.com/stretchr/testify/require"
 )
 
+var tls13CipherSuites = []uint16{tls.TLS_AES_128_GCM_SHA256, tls.TLS_AES_256_GCM_SHA384, tls.TLS_CHACHA20_POLY1305_SHA256}
+
 type cipherSuiteTLS13 struct {
 	ID     uint16
 	KeyLen int
@@ -32,43 +33,31 @@ func cipherSuiteTLS13ByID(id uint16) *cipherSuiteTLS13 {
 	return nil
 }
 
-//go:linkname expandLabel crypto/tls.(*cipherSuiteTLS13).expandLabel
+//go:linkname nextTrafficSecret crypto/tls.(*cipherSuiteTLS13).nextTrafficSecret
-func expandLabel(cs *cipherSuiteTLS13, secret []byte, label string, context []byte, length int) []byte
+func nextTrafficSecret(cs *cipherSuiteTLS13, trafficSecret []byte) []byte
 
 func TestHKDF(t *testing.T) {
-	testCases := []struct {
+	for _, id := range tls13CipherSuites {
-		name        string
+		t.Run(tls.CipherSuiteName(id), func(t *testing.T) {
-		cipherSuite uint16
+			cs := cipherSuiteTLS13ByID(id)
-		secret      []byte
+			expected := nextTrafficSecret(cs, []byte("foobar"))
-		context     []byte
+			expanded := hkdfExpandLabel(cs.Hash, []byte("foobar"), nil, "traffic upd", cs.Hash.Size())
-		label       string
-		length      int
-	}{
-		{"TLS_AES_128_GCM_SHA256", tls.TLS_AES_128_GCM_SHA256, []byte("secret"), []byte("context"), "label", 42},
-		{"TLS_AES_256_GCM_SHA384", tls.TLS_AES_256_GCM_SHA384, []byte("secret"), []byte("context"), "label", 100},
-		{"TLS_CHACHA20_POLY1305_SHA256", tls.TLS_CHACHA20_POLY1305_SHA256, []byte("secret"), []byte("context"), "label", 77},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			cs := cipherSuiteTLS13ByID(tc.cipherSuite)
-			expected := expandLabel(cs, tc.secret, tc.label, tc.context, tc.length)
-			expanded := hkdfExpandLabel(cs.Hash, tc.secret, tc.context, tc.label, tc.length)
 			require.Equal(t, expected, expanded)
 		})
 	}
 }
 
+// As of Go 1.24, the standard library and our implementation of hkdfExpandLabel should provide the same performance.
 func BenchmarkHKDFExpandLabelStandardLibrary(b *testing.B) {
-	b.Run("TLS_AES_128_GCM_SHA256", func(b *testing.B) { benchmarkHKDFExpandLabel(b, tls.TLS_AES_128_GCM_SHA256, true) })
+	for _, id := range tls13CipherSuites {
-	b.Run("TLS_AES_256_GCM_SHA384", func(b *testing.B) { benchmarkHKDFExpandLabel(b, tls.TLS_AES_256_GCM_SHA384, true) })
+		b.Run(tls.CipherSuiteName(id), func(b *testing.B) { benchmarkHKDFExpandLabel(b, id, true) })
-	b.Run("TLS_CHACHA20_POLY1305_SHA256", func(b *testing.B) { benchmarkHKDFExpandLabel(b, tls.TLS_CHACHA20_POLY1305_SHA256, true) })
+	}
 }
 
-func BenchmarkHKDFExpandLabelOptimized(b *testing.B) {
+func BenchmarkHKDFExpandLabelOurs(b *testing.B) {
-	b.Run("TLS_AES_128_GCM_SHA256", func(b *testing.B) { benchmarkHKDFExpandLabel(b, tls.TLS_AES_128_GCM_SHA256, false) })
+	for _, id := range tls13CipherSuites {
-	b.Run("TLS_AES_256_GCM_SHA384", func(b *testing.B) { benchmarkHKDFExpandLabel(b, tls.TLS_AES_256_GCM_SHA384, false) })
+		b.Run(tls.CipherSuiteName(id), func(b *testing.B) { benchmarkHKDFExpandLabel(b, id, false) })
-	b.Run("TLS_CHACHA20_POLY1305_SHA256", func(b *testing.B) { benchmarkHKDFExpandLabel(b, tls.TLS_CHACHA20_POLY1305_SHA256, false) })
+	}
 }
 
 func benchmarkHKDFExpandLabel(b *testing.B, cipherSuite uint16, useStdLib bool) {
@@ -79,9 +68,9 @@ func benchmarkHKDFExpandLabel(b *testing.B, cipherSuite uint16, useStdLib bool)
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		if useStdLib {
-			expandLabel(cs, secret, "label", []byte("context"), 42)
+			nextTrafficSecret(cs, secret)
 		} else {
-			hkdfExpandLabel(cs.Hash, secret, []byte("context"), "label", 42)
+			hkdfExpandLabel(cs.Hash, secret, nil, "traffic upd", cs.Hash.Size())
 		}
 	}
 }

internal/mocks/logging/internal/connection_tracer.go

@@ -14,9 +14,6 @@ import (
 	reflect "reflect"
 	time "time"
 
-	protocol "github.com/quic-go/quic-go/internal/protocol"
-	utils "github.com/quic-go/quic-go/internal/utils"
-	wire "github.com/quic-go/quic-go/internal/wire"
 	logging "github.com/quic-go/quic-go/logging"
 	gomock "go.uber.org/mock/gomock"
 )
@@ -46,7 +43,7 @@ func (m *MockConnectionTracer) EXPECT() *MockConnectionTracerMockRecorder {
 }
 
 // AcknowledgedPacket mocks base method.
-func (m *MockConnectionTracer) AcknowledgedPacket(arg0 protocol.EncryptionLevel, arg1 protocol.PacketNumber) {
+func (m *MockConnectionTracer) AcknowledgedPacket(arg0 logging.EncryptionLevel, arg1 logging.PacketNumber) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "AcknowledgedPacket", arg0, arg1)
 }
@@ -70,19 +67,19 @@ func (c *MockConnectionTracerAcknowledgedPacketCall) Return() *MockConnectionTra
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerAcknowledgedPacketCall) Do(f func(protocol.EncryptionLevel, protocol.PacketNumber)) *MockConnectionTracerAcknowledgedPacketCall {
+func (c *MockConnectionTracerAcknowledgedPacketCall) Do(f func(logging.EncryptionLevel, logging.PacketNumber)) *MockConnectionTracerAcknowledgedPacketCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerAcknowledgedPacketCall) DoAndReturn(f func(protocol.EncryptionLevel, protocol.PacketNumber)) *MockConnectionTracerAcknowledgedPacketCall {
+func (c *MockConnectionTracerAcknowledgedPacketCall) DoAndReturn(f func(logging.EncryptionLevel, logging.PacketNumber)) *MockConnectionTracerAcknowledgedPacketCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // BufferedPacket mocks base method.
-func (m *MockConnectionTracer) BufferedPacket(arg0 logging.PacketType, arg1 protocol.ByteCount) {
+func (m *MockConnectionTracer) BufferedPacket(arg0 logging.PacketType, arg1 logging.ByteCount) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "BufferedPacket", arg0, arg1)
 }
@@ -106,13 +103,13 @@ func (c *MockConnectionTracerBufferedPacketCall) Return() *MockConnectionTracerB
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerBufferedPacketCall) Do(f func(logging.PacketType, protocol.ByteCount)) *MockConnectionTracerBufferedPacketCall {
+func (c *MockConnectionTracerBufferedPacketCall) Do(f func(logging.PacketType, logging.ByteCount)) *MockConnectionTracerBufferedPacketCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerBufferedPacketCall) DoAndReturn(f func(logging.PacketType, protocol.ByteCount)) *MockConnectionTracerBufferedPacketCall {
+func (c *MockConnectionTracerBufferedPacketCall) DoAndReturn(f func(logging.PacketType, logging.ByteCount)) *MockConnectionTracerBufferedPacketCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
@@ -262,7 +259,7 @@ func (c *MockConnectionTracerDebugCall) DoAndReturn(f func(string, string)) *Moc
 }
 
 // DroppedEncryptionLevel mocks base method.
-func (m *MockConnectionTracer) DroppedEncryptionLevel(arg0 protocol.EncryptionLevel) {
+func (m *MockConnectionTracer) DroppedEncryptionLevel(arg0 logging.EncryptionLevel) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DroppedEncryptionLevel", arg0)
 }
@@ -286,19 +283,19 @@ func (c *MockConnectionTracerDroppedEncryptionLevelCall) Return() *MockConnectio
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerDroppedEncryptionLevelCall) Do(f func(protocol.EncryptionLevel)) *MockConnectionTracerDroppedEncryptionLevelCall {
+func (c *MockConnectionTracerDroppedEncryptionLevelCall) Do(f func(logging.EncryptionLevel)) *MockConnectionTracerDroppedEncryptionLevelCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerDroppedEncryptionLevelCall) DoAndReturn(f func(protocol.EncryptionLevel)) *MockConnectionTracerDroppedEncryptionLevelCall {
+func (c *MockConnectionTracerDroppedEncryptionLevelCall) DoAndReturn(f func(logging.EncryptionLevel)) *MockConnectionTracerDroppedEncryptionLevelCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // DroppedKey mocks base method.
-func (m *MockConnectionTracer) DroppedKey(generation protocol.KeyPhase) {
+func (m *MockConnectionTracer) DroppedKey(generation logging.KeyPhase) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DroppedKey", generation)
 }
@@ -322,19 +319,19 @@ func (c *MockConnectionTracerDroppedKeyCall) Return() *MockConnectionTracerDropp
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerDroppedKeyCall) Do(f func(protocol.KeyPhase)) *MockConnectionTracerDroppedKeyCall {
+func (c *MockConnectionTracerDroppedKeyCall) Do(f func(logging.KeyPhase)) *MockConnectionTracerDroppedKeyCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerDroppedKeyCall) DoAndReturn(f func(protocol.KeyPhase)) *MockConnectionTracerDroppedKeyCall {
+func (c *MockConnectionTracerDroppedKeyCall) DoAndReturn(f func(logging.KeyPhase)) *MockConnectionTracerDroppedKeyCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // DroppedPacket mocks base method.
-func (m *MockConnectionTracer) DroppedPacket(arg0 logging.PacketType, arg1 protocol.PacketNumber, arg2 protocol.ByteCount, arg3 logging.PacketDropReason) {
+func (m *MockConnectionTracer) DroppedPacket(arg0 logging.PacketType, arg1 logging.PacketNumber, arg2 logging.ByteCount, arg3 logging.PacketDropReason) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DroppedPacket", arg0, arg1, arg2, arg3)
 }
@@ -358,13 +355,13 @@ func (c *MockConnectionTracerDroppedPacketCall) Return() *MockConnectionTracerDr
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerDroppedPacketCall) Do(f func(logging.PacketType, protocol.PacketNumber, protocol.ByteCount, logging.PacketDropReason)) *MockConnectionTracerDroppedPacketCall {
+func (c *MockConnectionTracerDroppedPacketCall) Do(f func(logging.PacketType, logging.PacketNumber, logging.ByteCount, logging.PacketDropReason)) *MockConnectionTracerDroppedPacketCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerDroppedPacketCall) DoAndReturn(f func(logging.PacketType, protocol.PacketNumber, protocol.ByteCount, logging.PacketDropReason)) *MockConnectionTracerDroppedPacketCall {
+func (c *MockConnectionTracerDroppedPacketCall) DoAndReturn(f func(logging.PacketType, logging.PacketNumber, logging.ByteCount, logging.PacketDropReason)) *MockConnectionTracerDroppedPacketCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
@@ -442,7 +439,7 @@ func (c *MockConnectionTracerLossTimerCanceledCall) DoAndReturn(f func()) *MockC
 }
 
 // LossTimerExpired mocks base method.
-func (m *MockConnectionTracer) LossTimerExpired(arg0 logging.TimerType, arg1 protocol.EncryptionLevel) {
+func (m *MockConnectionTracer) LossTimerExpired(arg0 logging.TimerType, arg1 logging.EncryptionLevel) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "LossTimerExpired", arg0, arg1)
 }
@@ -466,19 +463,19 @@ func (c *MockConnectionTracerLossTimerExpiredCall) Return() *MockConnectionTrace
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerLossTimerExpiredCall) Do(f func(logging.TimerType, protocol.EncryptionLevel)) *MockConnectionTracerLossTimerExpiredCall {
+func (c *MockConnectionTracerLossTimerExpiredCall) Do(f func(logging.TimerType, logging.EncryptionLevel)) *MockConnectionTracerLossTimerExpiredCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerLossTimerExpiredCall) DoAndReturn(f func(logging.TimerType, protocol.EncryptionLevel)) *MockConnectionTracerLossTimerExpiredCall {
+func (c *MockConnectionTracerLossTimerExpiredCall) DoAndReturn(f func(logging.TimerType, logging.EncryptionLevel)) *MockConnectionTracerLossTimerExpiredCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // LostPacket mocks base method.
-func (m *MockConnectionTracer) LostPacket(arg0 protocol.EncryptionLevel, arg1 protocol.PacketNumber, arg2 logging.PacketLossReason) {
+func (m *MockConnectionTracer) LostPacket(arg0 logging.EncryptionLevel, arg1 logging.PacketNumber, arg2 logging.PacketLossReason) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "LostPacket", arg0, arg1, arg2)
 }
@@ -502,19 +499,19 @@ func (c *MockConnectionTracerLostPacketCall) Return() *MockConnectionTracerLostP
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerLostPacketCall) Do(f func(protocol.EncryptionLevel, protocol.PacketNumber, logging.PacketLossReason)) *MockConnectionTracerLostPacketCall {
+func (c *MockConnectionTracerLostPacketCall) Do(f func(logging.EncryptionLevel, logging.PacketNumber, logging.PacketLossReason)) *MockConnectionTracerLostPacketCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerLostPacketCall) DoAndReturn(f func(protocol.EncryptionLevel, protocol.PacketNumber, logging.PacketLossReason)) *MockConnectionTracerLostPacketCall {
+func (c *MockConnectionTracerLostPacketCall) DoAndReturn(f func(logging.EncryptionLevel, logging.PacketNumber, logging.PacketLossReason)) *MockConnectionTracerLostPacketCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // NegotiatedVersion mocks base method.
-func (m *MockConnectionTracer) NegotiatedVersion(chosen protocol.Version, clientVersions, serverVersions []protocol.Version) {
+func (m *MockConnectionTracer) NegotiatedVersion(chosen logging.Version, clientVersions, serverVersions []logging.Version) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "NegotiatedVersion", chosen, clientVersions, serverVersions)
 }
@@ -538,19 +535,19 @@ func (c *MockConnectionTracerNegotiatedVersionCall) Return() *MockConnectionTrac
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerNegotiatedVersionCall) Do(f func(protocol.Version, []protocol.Version, []protocol.Version)) *MockConnectionTracerNegotiatedVersionCall {
+func (c *MockConnectionTracerNegotiatedVersionCall) Do(f func(logging.Version, []logging.Version, []logging.Version)) *MockConnectionTracerNegotiatedVersionCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerNegotiatedVersionCall) DoAndReturn(f func(protocol.Version, []protocol.Version, []protocol.Version)) *MockConnectionTracerNegotiatedVersionCall {
+func (c *MockConnectionTracerNegotiatedVersionCall) DoAndReturn(f func(logging.Version, []logging.Version, []logging.Version)) *MockConnectionTracerNegotiatedVersionCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // ReceivedLongHeaderPacket mocks base method.
-func (m *MockConnectionTracer) ReceivedLongHeaderPacket(arg0 *wire.ExtendedHeader, arg1 protocol.ByteCount, arg2 protocol.ECN, arg3 []logging.Frame) {
+func (m *MockConnectionTracer) ReceivedLongHeaderPacket(arg0 *logging.ExtendedHeader, arg1 logging.ByteCount, arg2 logging.ECN, arg3 []logging.Frame) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedLongHeaderPacket", arg0, arg1, arg2, arg3)
 }
@@ -574,19 +571,19 @@ func (c *MockConnectionTracerReceivedLongHeaderPacketCall) Return() *MockConnect
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerReceivedLongHeaderPacketCall) Do(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *MockConnectionTracerReceivedLongHeaderPacketCall {
+func (c *MockConnectionTracerReceivedLongHeaderPacketCall) Do(f func(*logging.ExtendedHeader, logging.ByteCount, logging.ECN, []logging.Frame)) *MockConnectionTracerReceivedLongHeaderPacketCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerReceivedLongHeaderPacketCall) DoAndReturn(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *MockConnectionTracerReceivedLongHeaderPacketCall {
+func (c *MockConnectionTracerReceivedLongHeaderPacketCall) DoAndReturn(f func(*logging.ExtendedHeader, logging.ByteCount, logging.ECN, []logging.Frame)) *MockConnectionTracerReceivedLongHeaderPacketCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // ReceivedRetry mocks base method.
-func (m *MockConnectionTracer) ReceivedRetry(arg0 *wire.Header) {
+func (m *MockConnectionTracer) ReceivedRetry(arg0 *logging.Header) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedRetry", arg0)
 }
@@ -610,19 +607,19 @@ func (c *MockConnectionTracerReceivedRetryCall) Return() *MockConnectionTracerRe
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerReceivedRetryCall) Do(f func(*wire.Header)) *MockConnectionTracerReceivedRetryCall {
+func (c *MockConnectionTracerReceivedRetryCall) Do(f func(*logging.Header)) *MockConnectionTracerReceivedRetryCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerReceivedRetryCall) DoAndReturn(f func(*wire.Header)) *MockConnectionTracerReceivedRetryCall {
+func (c *MockConnectionTracerReceivedRetryCall) DoAndReturn(f func(*logging.Header)) *MockConnectionTracerReceivedRetryCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // ReceivedShortHeaderPacket mocks base method.
-func (m *MockConnectionTracer) ReceivedShortHeaderPacket(arg0 *logging.ShortHeader, arg1 protocol.ByteCount, arg2 protocol.ECN, arg3 []logging.Frame) {
+func (m *MockConnectionTracer) ReceivedShortHeaderPacket(arg0 *logging.ShortHeader, arg1 logging.ByteCount, arg2 logging.ECN, arg3 []logging.Frame) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedShortHeaderPacket", arg0, arg1, arg2, arg3)
 }
@@ -646,19 +643,19 @@ func (c *MockConnectionTracerReceivedShortHeaderPacketCall) Return() *MockConnec
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerReceivedShortHeaderPacketCall) Do(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *MockConnectionTracerReceivedShortHeaderPacketCall {
+func (c *MockConnectionTracerReceivedShortHeaderPacketCall) Do(f func(*logging.ShortHeader, logging.ByteCount, logging.ECN, []logging.Frame)) *MockConnectionTracerReceivedShortHeaderPacketCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerReceivedShortHeaderPacketCall) DoAndReturn(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *MockConnectionTracerReceivedShortHeaderPacketCall {
+func (c *MockConnectionTracerReceivedShortHeaderPacketCall) DoAndReturn(f func(*logging.ShortHeader, logging.ByteCount, logging.ECN, []logging.Frame)) *MockConnectionTracerReceivedShortHeaderPacketCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // ReceivedTransportParameters mocks base method.
-func (m *MockConnectionTracer) ReceivedTransportParameters(arg0 *wire.TransportParameters) {
+func (m *MockConnectionTracer) ReceivedTransportParameters(arg0 *logging.TransportParameters) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedTransportParameters", arg0)
 }
@@ -682,19 +679,19 @@ func (c *MockConnectionTracerReceivedTransportParametersCall) Return() *MockConn
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerReceivedTransportParametersCall) Do(f func(*wire.TransportParameters)) *MockConnectionTracerReceivedTransportParametersCall {
+func (c *MockConnectionTracerReceivedTransportParametersCall) Do(f func(*logging.TransportParameters)) *MockConnectionTracerReceivedTransportParametersCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerReceivedTransportParametersCall) DoAndReturn(f func(*wire.TransportParameters)) *MockConnectionTracerReceivedTransportParametersCall {
+func (c *MockConnectionTracerReceivedTransportParametersCall) DoAndReturn(f func(*logging.TransportParameters)) *MockConnectionTracerReceivedTransportParametersCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // ReceivedVersionNegotiationPacket mocks base method.
-func (m *MockConnectionTracer) ReceivedVersionNegotiationPacket(dest, src protocol.ArbitraryLenConnectionID, arg2 []protocol.Version) {
+func (m *MockConnectionTracer) ReceivedVersionNegotiationPacket(dest, src logging.ArbitraryLenConnectionID, arg2 []logging.Version) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedVersionNegotiationPacket", dest, src, arg2)
 }
@@ -718,19 +715,19 @@ func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) Return() *Moc
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) Do(f func(protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *MockConnectionTracerReceivedVersionNegotiationPacketCall {
+func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) Do(f func(logging.ArbitraryLenConnectionID, logging.ArbitraryLenConnectionID, []logging.Version)) *MockConnectionTracerReceivedVersionNegotiationPacketCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) DoAndReturn(f func(protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *MockConnectionTracerReceivedVersionNegotiationPacketCall {
+func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) DoAndReturn(f func(logging.ArbitraryLenConnectionID, logging.ArbitraryLenConnectionID, []logging.Version)) *MockConnectionTracerReceivedVersionNegotiationPacketCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // RestoredTransportParameters mocks base method.
-func (m *MockConnectionTracer) RestoredTransportParameters(parameters *wire.TransportParameters) {
+func (m *MockConnectionTracer) RestoredTransportParameters(parameters *logging.TransportParameters) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "RestoredTransportParameters", parameters)
 }
@@ -754,19 +751,19 @@ func (c *MockConnectionTracerRestoredTransportParametersCall) Return() *MockConn
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerRestoredTransportParametersCall) Do(f func(*wire.TransportParameters)) *MockConnectionTracerRestoredTransportParametersCall {
+func (c *MockConnectionTracerRestoredTransportParametersCall) Do(f func(*logging.TransportParameters)) *MockConnectionTracerRestoredTransportParametersCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerRestoredTransportParametersCall) DoAndReturn(f func(*wire.TransportParameters)) *MockConnectionTracerRestoredTransportParametersCall {
+func (c *MockConnectionTracerRestoredTransportParametersCall) DoAndReturn(f func(*logging.TransportParameters)) *MockConnectionTracerRestoredTransportParametersCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // SentLongHeaderPacket mocks base method.
-func (m *MockConnectionTracer) SentLongHeaderPacket(arg0 *wire.ExtendedHeader, arg1 protocol.ByteCount, arg2 protocol.ECN, arg3 *wire.AckFrame, arg4 []logging.Frame) {
+func (m *MockConnectionTracer) SentLongHeaderPacket(arg0 *logging.ExtendedHeader, arg1 logging.ByteCount, arg2 logging.ECN, arg3 *logging.AckFrame, arg4 []logging.Frame) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SentLongHeaderPacket", arg0, arg1, arg2, arg3, arg4)
 }
@@ -790,19 +787,19 @@ func (c *MockConnectionTracerSentLongHeaderPacketCall) Return() *MockConnectionT
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerSentLongHeaderPacketCall) Do(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *MockConnectionTracerSentLongHeaderPacketCall {
+func (c *MockConnectionTracerSentLongHeaderPacketCall) Do(f func(*logging.ExtendedHeader, logging.ByteCount, logging.ECN, *logging.AckFrame, []logging.Frame)) *MockConnectionTracerSentLongHeaderPacketCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerSentLongHeaderPacketCall) DoAndReturn(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *MockConnectionTracerSentLongHeaderPacketCall {
+func (c *MockConnectionTracerSentLongHeaderPacketCall) DoAndReturn(f func(*logging.ExtendedHeader, logging.ByteCount, logging.ECN, *logging.AckFrame, []logging.Frame)) *MockConnectionTracerSentLongHeaderPacketCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // SentShortHeaderPacket mocks base method.
-func (m *MockConnectionTracer) SentShortHeaderPacket(arg0 *logging.ShortHeader, arg1 protocol.ByteCount, arg2 protocol.ECN, arg3 *wire.AckFrame, arg4 []logging.Frame) {
+func (m *MockConnectionTracer) SentShortHeaderPacket(arg0 *logging.ShortHeader, arg1 logging.ByteCount, arg2 logging.ECN, arg3 *logging.AckFrame, arg4 []logging.Frame) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SentShortHeaderPacket", arg0, arg1, arg2, arg3, arg4)
 }
@@ -826,19 +823,19 @@ func (c *MockConnectionTracerSentShortHeaderPacketCall) Return() *MockConnection
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerSentShortHeaderPacketCall) Do(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *MockConnectionTracerSentShortHeaderPacketCall {
+func (c *MockConnectionTracerSentShortHeaderPacketCall) Do(f func(*logging.ShortHeader, logging.ByteCount, logging.ECN, *logging.AckFrame, []logging.Frame)) *MockConnectionTracerSentShortHeaderPacketCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerSentShortHeaderPacketCall) DoAndReturn(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *MockConnectionTracerSentShortHeaderPacketCall {
+func (c *MockConnectionTracerSentShortHeaderPacketCall) DoAndReturn(f func(*logging.ShortHeader, logging.ByteCount, logging.ECN, *logging.AckFrame, []logging.Frame)) *MockConnectionTracerSentShortHeaderPacketCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // SentTransportParameters mocks base method.
-func (m *MockConnectionTracer) SentTransportParameters(arg0 *wire.TransportParameters) {
+func (m *MockConnectionTracer) SentTransportParameters(arg0 *logging.TransportParameters) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SentTransportParameters", arg0)
 }
@@ -862,19 +859,19 @@ func (c *MockConnectionTracerSentTransportParametersCall) Return() *MockConnecti
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerSentTransportParametersCall) Do(f func(*wire.TransportParameters)) *MockConnectionTracerSentTransportParametersCall {
+func (c *MockConnectionTracerSentTransportParametersCall) Do(f func(*logging.TransportParameters)) *MockConnectionTracerSentTransportParametersCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerSentTransportParametersCall) DoAndReturn(f func(*wire.TransportParameters)) *MockConnectionTracerSentTransportParametersCall {
+func (c *MockConnectionTracerSentTransportParametersCall) DoAndReturn(f func(*logging.TransportParameters)) *MockConnectionTracerSentTransportParametersCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // SetLossTimer mocks base method.
-func (m *MockConnectionTracer) SetLossTimer(arg0 logging.TimerType, arg1 protocol.EncryptionLevel, arg2 time.Time) {
+func (m *MockConnectionTracer) SetLossTimer(arg0 logging.TimerType, arg1 logging.EncryptionLevel, arg2 time.Time) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetLossTimer", arg0, arg1, arg2)
 }
@@ -898,19 +895,19 @@ func (c *MockConnectionTracerSetLossTimerCall) Return() *MockConnectionTracerSet
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerSetLossTimerCall) Do(f func(logging.TimerType, protocol.EncryptionLevel, time.Time)) *MockConnectionTracerSetLossTimerCall {
+func (c *MockConnectionTracerSetLossTimerCall) Do(f func(logging.TimerType, logging.EncryptionLevel, time.Time)) *MockConnectionTracerSetLossTimerCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerSetLossTimerCall) DoAndReturn(f func(logging.TimerType, protocol.EncryptionLevel, time.Time)) *MockConnectionTracerSetLossTimerCall {
+func (c *MockConnectionTracerSetLossTimerCall) DoAndReturn(f func(logging.TimerType, logging.EncryptionLevel, time.Time)) *MockConnectionTracerSetLossTimerCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // StartedConnection mocks base method.
-func (m *MockConnectionTracer) StartedConnection(local, remote net.Addr, srcConnID, destConnID protocol.ConnectionID) {
+func (m *MockConnectionTracer) StartedConnection(local, remote net.Addr, srcConnID, destConnID logging.ConnectionID) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "StartedConnection", local, remote, srcConnID, destConnID)
 }
@@ -934,13 +931,13 @@ func (c *MockConnectionTracerStartedConnectionCall) Return() *MockConnectionTrac
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerStartedConnectionCall) Do(f func(net.Addr, net.Addr, protocol.ConnectionID, protocol.ConnectionID)) *MockConnectionTracerStartedConnectionCall {
+func (c *MockConnectionTracerStartedConnectionCall) Do(f func(net.Addr, net.Addr, logging.ConnectionID, logging.ConnectionID)) *MockConnectionTracerStartedConnectionCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerStartedConnectionCall) DoAndReturn(f func(net.Addr, net.Addr, protocol.ConnectionID, protocol.ConnectionID)) *MockConnectionTracerStartedConnectionCall {
+func (c *MockConnectionTracerStartedConnectionCall) DoAndReturn(f func(net.Addr, net.Addr, logging.ConnectionID, logging.ConnectionID)) *MockConnectionTracerStartedConnectionCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
@@ -982,7 +979,7 @@ func (c *MockConnectionTracerUpdatedCongestionStateCall) DoAndReturn(f func(logg
 }
 
 // UpdatedKey mocks base method.
-func (m *MockConnectionTracer) UpdatedKey(generation protocol.KeyPhase, remote bool) {
+func (m *MockConnectionTracer) UpdatedKey(generation logging.KeyPhase, remote bool) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatedKey", generation, remote)
 }
@@ -1006,19 +1003,19 @@ func (c *MockConnectionTracerUpdatedKeyCall) Return() *MockConnectionTracerUpdat
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerUpdatedKeyCall) Do(f func(protocol.KeyPhase, bool)) *MockConnectionTracerUpdatedKeyCall {
+func (c *MockConnectionTracerUpdatedKeyCall) Do(f func(logging.KeyPhase, bool)) *MockConnectionTracerUpdatedKeyCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerUpdatedKeyCall) DoAndReturn(f func(protocol.KeyPhase, bool)) *MockConnectionTracerUpdatedKeyCall {
+func (c *MockConnectionTracerUpdatedKeyCall) DoAndReturn(f func(logging.KeyPhase, bool)) *MockConnectionTracerUpdatedKeyCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // UpdatedKeyFromTLS mocks base method.
-func (m *MockConnectionTracer) UpdatedKeyFromTLS(arg0 protocol.EncryptionLevel, arg1 protocol.Perspective) {
+func (m *MockConnectionTracer) UpdatedKeyFromTLS(arg0 logging.EncryptionLevel, arg1 logging.Perspective) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatedKeyFromTLS", arg0, arg1)
 }
@@ -1042,19 +1039,19 @@ func (c *MockConnectionTracerUpdatedKeyFromTLSCall) Return() *MockConnectionTrac
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerUpdatedKeyFromTLSCall) Do(f func(protocol.EncryptionLevel, protocol.Perspective)) *MockConnectionTracerUpdatedKeyFromTLSCall {
+func (c *MockConnectionTracerUpdatedKeyFromTLSCall) Do(f func(logging.EncryptionLevel, logging.Perspective)) *MockConnectionTracerUpdatedKeyFromTLSCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerUpdatedKeyFromTLSCall) DoAndReturn(f func(protocol.EncryptionLevel, protocol.Perspective)) *MockConnectionTracerUpdatedKeyFromTLSCall {
+func (c *MockConnectionTracerUpdatedKeyFromTLSCall) DoAndReturn(f func(logging.EncryptionLevel, logging.Perspective)) *MockConnectionTracerUpdatedKeyFromTLSCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // UpdatedMTU mocks base method.
-func (m *MockConnectionTracer) UpdatedMTU(mtu protocol.ByteCount, done bool) {
+func (m *MockConnectionTracer) UpdatedMTU(mtu logging.ByteCount, done bool) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatedMTU", mtu, done)
 }
@@ -1078,19 +1075,19 @@ func (c *MockConnectionTracerUpdatedMTUCall) Return() *MockConnectionTracerUpdat
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerUpdatedMTUCall) Do(f func(protocol.ByteCount, bool)) *MockConnectionTracerUpdatedMTUCall {
+func (c *MockConnectionTracerUpdatedMTUCall) Do(f func(logging.ByteCount, bool)) *MockConnectionTracerUpdatedMTUCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerUpdatedMTUCall) DoAndReturn(f func(protocol.ByteCount, bool)) *MockConnectionTracerUpdatedMTUCall {
+func (c *MockConnectionTracerUpdatedMTUCall) DoAndReturn(f func(logging.ByteCount, bool)) *MockConnectionTracerUpdatedMTUCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // UpdatedMetrics mocks base method.
-func (m *MockConnectionTracer) UpdatedMetrics(rttStats *utils.RTTStats, cwnd, bytesInFlight protocol.ByteCount, packetsInFlight int) {
+func (m *MockConnectionTracer) UpdatedMetrics(rttStats *logging.RTTStats, cwnd, bytesInFlight logging.ByteCount, packetsInFlight int) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatedMetrics", rttStats, cwnd, bytesInFlight, packetsInFlight)
 }
@@ -1114,13 +1111,13 @@ func (c *MockConnectionTracerUpdatedMetricsCall) Return() *MockConnectionTracerU
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockConnectionTracerUpdatedMetricsCall) Do(f func(*utils.RTTStats, protocol.ByteCount, protocol.ByteCount, int)) *MockConnectionTracerUpdatedMetricsCall {
+func (c *MockConnectionTracerUpdatedMetricsCall) Do(f func(*logging.RTTStats, logging.ByteCount, logging.ByteCount, int)) *MockConnectionTracerUpdatedMetricsCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockConnectionTracerUpdatedMetricsCall) DoAndReturn(f func(*utils.RTTStats, protocol.ByteCount, protocol.ByteCount, int)) *MockConnectionTracerUpdatedMetricsCall {
+func (c *MockConnectionTracerUpdatedMetricsCall) DoAndReturn(f func(*logging.RTTStats, logging.ByteCount, logging.ByteCount, int)) *MockConnectionTracerUpdatedMetricsCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }

internal/mocks/logging/internal/tracer.go

@@ -13,8 +13,6 @@ import (
 	net "net"
 	reflect "reflect"
 
-	protocol "github.com/quic-go/quic-go/internal/protocol"
-	wire "github.com/quic-go/quic-go/internal/wire"
 	logging "github.com/quic-go/quic-go/logging"
 	gomock "go.uber.org/mock/gomock"
 )
@@ -116,7 +114,7 @@ func (c *MockTracerDebugCall) DoAndReturn(f func(string, string)) *MockTracerDeb
 }
 
 // DroppedPacket mocks base method.
-func (m *MockTracer) DroppedPacket(arg0 net.Addr, arg1 logging.PacketType, arg2 protocol.ByteCount, arg3 logging.PacketDropReason) {
+func (m *MockTracer) DroppedPacket(arg0 net.Addr, arg1 logging.PacketType, arg2 logging.ByteCount, arg3 logging.PacketDropReason) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DroppedPacket", arg0, arg1, arg2, arg3)
 }
@@ -140,19 +138,19 @@ func (c *MockTracerDroppedPacketCall) Return() *MockTracerDroppedPacketCall {
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockTracerDroppedPacketCall) Do(f func(net.Addr, logging.PacketType, protocol.ByteCount, logging.PacketDropReason)) *MockTracerDroppedPacketCall {
+func (c *MockTracerDroppedPacketCall) Do(f func(net.Addr, logging.PacketType, logging.ByteCount, logging.PacketDropReason)) *MockTracerDroppedPacketCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockTracerDroppedPacketCall) DoAndReturn(f func(net.Addr, logging.PacketType, protocol.ByteCount, logging.PacketDropReason)) *MockTracerDroppedPacketCall {
+func (c *MockTracerDroppedPacketCall) DoAndReturn(f func(net.Addr, logging.PacketType, logging.ByteCount, logging.PacketDropReason)) *MockTracerDroppedPacketCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // SentPacket mocks base method.
-func (m *MockTracer) SentPacket(arg0 net.Addr, arg1 *wire.Header, arg2 protocol.ByteCount, arg3 []logging.Frame) {
+func (m *MockTracer) SentPacket(arg0 net.Addr, arg1 *logging.Header, arg2 logging.ByteCount, arg3 []logging.Frame) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SentPacket", arg0, arg1, arg2, arg3)
 }
@@ -176,19 +174,19 @@ func (c *MockTracerSentPacketCall) Return() *MockTracerSentPacketCall {
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockTracerSentPacketCall) Do(f func(net.Addr, *wire.Header, protocol.ByteCount, []logging.Frame)) *MockTracerSentPacketCall {
+func (c *MockTracerSentPacketCall) Do(f func(net.Addr, *logging.Header, logging.ByteCount, []logging.Frame)) *MockTracerSentPacketCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockTracerSentPacketCall) DoAndReturn(f func(net.Addr, *wire.Header, protocol.ByteCount, []logging.Frame)) *MockTracerSentPacketCall {
+func (c *MockTracerSentPacketCall) DoAndReturn(f func(net.Addr, *logging.Header, logging.ByteCount, []logging.Frame)) *MockTracerSentPacketCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // SentVersionNegotiationPacket mocks base method.
-func (m *MockTracer) SentVersionNegotiationPacket(arg0 net.Addr, dest, src protocol.ArbitraryLenConnectionID, arg3 []protocol.Version) {
+func (m *MockTracer) SentVersionNegotiationPacket(arg0 net.Addr, dest, src logging.ArbitraryLenConnectionID, arg3 []logging.Version) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SentVersionNegotiationPacket", arg0, dest, src, arg3)
 }
@@ -212,13 +210,13 @@ func (c *MockTracerSentVersionNegotiationPacketCall) Return() *MockTracerSentVer
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockTracerSentVersionNegotiationPacketCall) Do(f func(net.Addr, protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *MockTracerSentVersionNegotiationPacketCall {
+func (c *MockTracerSentVersionNegotiationPacketCall) Do(f func(net.Addr, logging.ArbitraryLenConnectionID, logging.ArbitraryLenConnectionID, []logging.Version)) *MockTracerSentVersionNegotiationPacketCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockTracerSentVersionNegotiationPacketCall) DoAndReturn(f func(net.Addr, protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *MockTracerSentVersionNegotiationPacketCall {
+func (c *MockTracerSentVersionNegotiationPacketCall) DoAndReturn(f func(net.Addr, logging.ArbitraryLenConnectionID, logging.ArbitraryLenConnectionID, []logging.Version)) *MockTracerSentVersionNegotiationPacketCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }

internal/mocks/quic/early_conn.go

@@ -15,7 +15,6 @@ import (
 	reflect "reflect"
 
 	quic "github.com/quic-go/quic-go"
-	qerr "github.com/quic-go/quic-go/internal/qerr"
 	gomock "go.uber.org/mock/gomock"
 )
 
@@ -122,7 +121,7 @@ func (c *MockEarlyConnectionAcceptUniStreamCall) DoAndReturn(f func(context.Cont
 }
 
 // CloseWithError mocks base method.
-func (m *MockEarlyConnection) CloseWithError(arg0 qerr.ApplicationErrorCode, arg1 string) error {
+func (m *MockEarlyConnection) CloseWithError(arg0 quic.ApplicationErrorCode, arg1 string) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CloseWithError", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -148,13 +147,13 @@ func (c *MockEarlyConnectionCloseWithErrorCall) Return(arg0 error) *MockEarlyCon
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockEarlyConnectionCloseWithErrorCall) Do(f func(qerr.ApplicationErrorCode, string) error) *MockEarlyConnectionCloseWithErrorCall {
+func (c *MockEarlyConnectionCloseWithErrorCall) Do(f func(quic.ApplicationErrorCode, string) error) *MockEarlyConnectionCloseWithErrorCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockEarlyConnectionCloseWithErrorCall) DoAndReturn(f func(qerr.ApplicationErrorCode, string) error) *MockEarlyConnectionCloseWithErrorCall {
+func (c *MockEarlyConnectionCloseWithErrorCall) DoAndReturn(f func(quic.ApplicationErrorCode, string) error) *MockEarlyConnectionCloseWithErrorCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }

internal/mocks/quic/stream.go

@@ -14,8 +14,7 @@ import (
 	reflect "reflect"
 	time "time"
 
-	protocol "github.com/quic-go/quic-go/internal/protocol"
+	quic "github.com/quic-go/quic-go"
-	qerr "github.com/quic-go/quic-go/internal/qerr"
 	gomock "go.uber.org/mock/gomock"
 )
 
@@ -44,7 +43,7 @@ func (m *MockStream) EXPECT() *MockStreamMockRecorder {
 }
 
 // CancelRead mocks base method.
-func (m *MockStream) CancelRead(arg0 qerr.StreamErrorCode) {
+func (m *MockStream) CancelRead(arg0 quic.StreamErrorCode) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "CancelRead", arg0)
 }
@@ -68,19 +67,19 @@ func (c *MockStreamCancelReadCall) Return() *MockStreamCancelReadCall {
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockStreamCancelReadCall) Do(f func(qerr.StreamErrorCode)) *MockStreamCancelReadCall {
+func (c *MockStreamCancelReadCall) Do(f func(quic.StreamErrorCode)) *MockStreamCancelReadCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockStreamCancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamCancelReadCall {
+func (c *MockStreamCancelReadCall) DoAndReturn(f func(quic.StreamErrorCode)) *MockStreamCancelReadCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // CancelWrite mocks base method.
-func (m *MockStream) CancelWrite(arg0 qerr.StreamErrorCode) {
+func (m *MockStream) CancelWrite(arg0 quic.StreamErrorCode) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "CancelWrite", arg0)
 }
@@ -104,13 +103,13 @@ func (c *MockStreamCancelWriteCall) Return() *MockStreamCancelWriteCall {
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockStreamCancelWriteCall) Do(f func(qerr.StreamErrorCode)) *MockStreamCancelWriteCall {
+func (c *MockStreamCancelWriteCall) Do(f func(quic.StreamErrorCode)) *MockStreamCancelWriteCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockStreamCancelWriteCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamCancelWriteCall {
+func (c *MockStreamCancelWriteCall) DoAndReturn(f func(quic.StreamErrorCode)) *MockStreamCancelWriteCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
@@ -345,10 +344,10 @@ func (c *MockStreamSetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *M
 }
 
 // StreamID mocks base method.
-func (m *MockStream) StreamID() protocol.StreamID {
+func (m *MockStream) StreamID() quic.StreamID {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StreamID")
-	ret0, _ := ret[0].(protocol.StreamID)
+	ret0, _ := ret[0].(quic.StreamID)
 	return ret0
 }
 
@@ -365,19 +364,19 @@ type MockStreamStreamIDCall struct {
 }
 
 // Return rewrite *gomock.Call.Return
-func (c *MockStreamStreamIDCall) Return(arg0 protocol.StreamID) *MockStreamStreamIDCall {
+func (c *MockStreamStreamIDCall) Return(arg0 quic.StreamID) *MockStreamStreamIDCall {
 	c.Call = c.Call.Return(arg0)
 	return c
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockStreamStreamIDCall) Do(f func() protocol.StreamID) *MockStreamStreamIDCall {
+func (c *MockStreamStreamIDCall) Do(f func() quic.StreamID) *MockStreamStreamIDCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockStreamStreamIDCall) DoAndReturn(f func() protocol.StreamID) *MockStreamStreamIDCall {
+func (c *MockStreamStreamIDCall) DoAndReturn(f func() quic.StreamID) *MockStreamStreamIDCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }

interop/Dockerfile

@@ -5,7 +5,7 @@ RUN echo "TARGETPLATFORM: ${TARGETPLATFORM}"
 
 RUN apt-get update && apt-get install -y wget tar git
 
-ENV GOVERSION=1.23.0
+ENV GOVERSION=1.24.0
 
 RUN platform=$(echo ${TARGETPLATFORM} | tr '/' '-') && \
   filename="go${GOVERSION}.${platform}.tar.gz" && \

mock_quic_conn_test.go

@@ -14,7 +14,6 @@ import (
 	net "net"
 	reflect "reflect"
 
-	qerr "github.com/quic-go/quic-go/internal/qerr"
 	gomock "go.uber.org/mock/gomock"
 )
 
@@ -121,7 +120,7 @@ func (c *MockQUICConnAcceptUniStreamCall) DoAndReturn(f func(context.Context) (R
 }
 
 // CloseWithError mocks base method.
-func (m *MockQUICConn) CloseWithError(arg0 qerr.ApplicationErrorCode, arg1 string) error {
+func (m *MockQUICConn) CloseWithError(arg0 ApplicationErrorCode, arg1 string) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CloseWithError", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -147,13 +146,13 @@ func (c *MockQUICConnCloseWithErrorCall) Return(arg0 error) *MockQUICConnCloseWi
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockQUICConnCloseWithErrorCall) Do(f func(qerr.ApplicationErrorCode, string) error) *MockQUICConnCloseWithErrorCall {
+func (c *MockQUICConnCloseWithErrorCall) Do(f func(ApplicationErrorCode, string) error) *MockQUICConnCloseWithErrorCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockQUICConnCloseWithErrorCall) DoAndReturn(f func(qerr.ApplicationErrorCode, string) error) *MockQUICConnCloseWithErrorCall {
+func (c *MockQUICConnCloseWithErrorCall) DoAndReturn(f func(ApplicationErrorCode, string) error) *MockQUICConnCloseWithErrorCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
@@ -621,7 +620,7 @@ func (c *MockQUICConnSendDatagramCall) DoAndReturn(f func([]byte) error) *MockQU
 }
 
 // closeWithTransportError mocks base method.
-func (m *MockQUICConn) closeWithTransportError(arg0 qerr.TransportErrorCode) {
+func (m *MockQUICConn) closeWithTransportError(arg0 TransportErrorCode) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "closeWithTransportError", arg0)
 }
@@ -645,13 +644,13 @@ func (c *MockQUICConncloseWithTransportErrorCall) Return() *MockQUICConncloseWit
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockQUICConncloseWithTransportErrorCall) Do(f func(qerr.TransportErrorCode)) *MockQUICConncloseWithTransportErrorCall {
+func (c *MockQUICConncloseWithTransportErrorCall) Do(f func(TransportErrorCode)) *MockQUICConncloseWithTransportErrorCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockQUICConncloseWithTransportErrorCall) DoAndReturn(f func(qerr.TransportErrorCode)) *MockQUICConncloseWithTransportErrorCall {
+func (c *MockQUICConncloseWithTransportErrorCall) DoAndReturn(f func(TransportErrorCode)) *MockQUICConncloseWithTransportErrorCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }

mock_receive_stream_internal_test.go

@@ -13,8 +13,6 @@ import (
 	reflect "reflect"
 	time "time"
 
-	protocol "github.com/quic-go/quic-go/internal/protocol"
-	qerr "github.com/quic-go/quic-go/internal/qerr"
 	wire "github.com/quic-go/quic-go/internal/wire"
 	gomock "go.uber.org/mock/gomock"
 )
@@ -44,7 +42,7 @@ func (m *MockReceiveStreamI) EXPECT() *MockReceiveStreamIMockRecorder {
 }
 
 // CancelRead mocks base method.
-func (m *MockReceiveStreamI) CancelRead(arg0 qerr.StreamErrorCode) {
+func (m *MockReceiveStreamI) CancelRead(arg0 StreamErrorCode) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "CancelRead", arg0)
 }
@@ -68,13 +66,13 @@ func (c *MockReceiveStreamICancelReadCall) Return() *MockReceiveStreamICancelRea
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockReceiveStreamICancelReadCall) Do(f func(qerr.StreamErrorCode)) *MockReceiveStreamICancelReadCall {
+func (c *MockReceiveStreamICancelReadCall) Do(f func(StreamErrorCode)) *MockReceiveStreamICancelReadCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockReceiveStreamICancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockReceiveStreamICancelReadCall {
+func (c *MockReceiveStreamICancelReadCall) DoAndReturn(f func(StreamErrorCode)) *MockReceiveStreamICancelReadCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
@@ -157,10 +155,10 @@ func (c *MockReceiveStreamISetReadDeadlineCall) DoAndReturn(f func(time.Time) er
 }
 
 // StreamID mocks base method.
-func (m *MockReceiveStreamI) StreamID() protocol.StreamID {
+func (m *MockReceiveStreamI) StreamID() StreamID {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StreamID")
-	ret0, _ := ret[0].(protocol.StreamID)
+	ret0, _ := ret[0].(StreamID)
 	return ret0
 }
 
@@ -177,19 +175,19 @@ type MockReceiveStreamIStreamIDCall struct {
 }
 
 // Return rewrite *gomock.Call.Return
-func (c *MockReceiveStreamIStreamIDCall) Return(arg0 protocol.StreamID) *MockReceiveStreamIStreamIDCall {
+func (c *MockReceiveStreamIStreamIDCall) Return(arg0 StreamID) *MockReceiveStreamIStreamIDCall {
 	c.Call = c.Call.Return(arg0)
 	return c
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockReceiveStreamIStreamIDCall) Do(f func() protocol.StreamID) *MockReceiveStreamIStreamIDCall {
+func (c *MockReceiveStreamIStreamIDCall) Do(f func() StreamID) *MockReceiveStreamIStreamIDCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockReceiveStreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *MockReceiveStreamIStreamIDCall {
+func (c *MockReceiveStreamIStreamIDCall) DoAndReturn(f func() StreamID) *MockReceiveStreamIStreamIDCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }

mock_send_stream_internal_test.go

@@ -16,7 +16,6 @@ import (
 
 	ackhandler "github.com/quic-go/quic-go/internal/ackhandler"
 	protocol "github.com/quic-go/quic-go/internal/protocol"
-	qerr "github.com/quic-go/quic-go/internal/qerr"
 	wire "github.com/quic-go/quic-go/internal/wire"
 	gomock "go.uber.org/mock/gomock"
 )
@@ -46,7 +45,7 @@ func (m *MockSendStreamI) EXPECT() *MockSendStreamIMockRecorder {
 }
 
 // CancelWrite mocks base method.
-func (m *MockSendStreamI) CancelWrite(arg0 qerr.StreamErrorCode) {
+func (m *MockSendStreamI) CancelWrite(arg0 StreamErrorCode) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "CancelWrite", arg0)
 }
@@ -70,13 +69,13 @@ func (c *MockSendStreamICancelWriteCall) Return() *MockSendStreamICancelWriteCal
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockSendStreamICancelWriteCall) Do(f func(qerr.StreamErrorCode)) *MockSendStreamICancelWriteCall {
+func (c *MockSendStreamICancelWriteCall) Do(f func(StreamErrorCode)) *MockSendStreamICancelWriteCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockSendStreamICancelWriteCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockSendStreamICancelWriteCall {
+func (c *MockSendStreamICancelWriteCall) DoAndReturn(f func(StreamErrorCode)) *MockSendStreamICancelWriteCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
@@ -196,10 +195,10 @@ func (c *MockSendStreamISetWriteDeadlineCall) DoAndReturn(f func(time.Time) erro
 }
 
 // StreamID mocks base method.
-func (m *MockSendStreamI) StreamID() protocol.StreamID {
+func (m *MockSendStreamI) StreamID() StreamID {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StreamID")
-	ret0, _ := ret[0].(protocol.StreamID)
+	ret0, _ := ret[0].(StreamID)
 	return ret0
 }
 
@@ -216,19 +215,19 @@ type MockSendStreamIStreamIDCall struct {
 }
 
 // Return rewrite *gomock.Call.Return
-func (c *MockSendStreamIStreamIDCall) Return(arg0 protocol.StreamID) *MockSendStreamIStreamIDCall {
+func (c *MockSendStreamIStreamIDCall) Return(arg0 StreamID) *MockSendStreamIStreamIDCall {
 	c.Call = c.Call.Return(arg0)
 	return c
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockSendStreamIStreamIDCall) Do(f func() protocol.StreamID) *MockSendStreamIStreamIDCall {
+func (c *MockSendStreamIStreamIDCall) Do(f func() StreamID) *MockSendStreamIStreamIDCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockSendStreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *MockSendStreamIStreamIDCall {
+func (c *MockSendStreamIStreamIDCall) DoAndReturn(f func() StreamID) *MockSendStreamIStreamIDCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }

mock_stream_internal_test.go

@@ -16,7 +16,6 @@ import (
 
 	ackhandler "github.com/quic-go/quic-go/internal/ackhandler"
 	protocol "github.com/quic-go/quic-go/internal/protocol"
-	qerr "github.com/quic-go/quic-go/internal/qerr"
 	wire "github.com/quic-go/quic-go/internal/wire"
 	gomock "go.uber.org/mock/gomock"
 )
@@ -46,7 +45,7 @@ func (m *MockStreamI) EXPECT() *MockStreamIMockRecorder {
 }
 
 // CancelRead mocks base method.
-func (m *MockStreamI) CancelRead(arg0 qerr.StreamErrorCode) {
+func (m *MockStreamI) CancelRead(arg0 StreamErrorCode) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "CancelRead", arg0)
 }
@@ -70,19 +69,19 @@ func (c *MockStreamICancelReadCall) Return() *MockStreamICancelReadCall {
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockStreamICancelReadCall) Do(f func(qerr.StreamErrorCode)) *MockStreamICancelReadCall {
+func (c *MockStreamICancelReadCall) Do(f func(StreamErrorCode)) *MockStreamICancelReadCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockStreamICancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamICancelReadCall {
+func (c *MockStreamICancelReadCall) DoAndReturn(f func(StreamErrorCode)) *MockStreamICancelReadCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
 
 // CancelWrite mocks base method.
-func (m *MockStreamI) CancelWrite(arg0 qerr.StreamErrorCode) {
+func (m *MockStreamI) CancelWrite(arg0 StreamErrorCode) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "CancelWrite", arg0)
 }
@@ -106,13 +105,13 @@ func (c *MockStreamICancelWriteCall) Return() *MockStreamICancelWriteCall {
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockStreamICancelWriteCall) Do(f func(qerr.StreamErrorCode)) *MockStreamICancelWriteCall {
+func (c *MockStreamICancelWriteCall) Do(f func(StreamErrorCode)) *MockStreamICancelWriteCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockStreamICancelWriteCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamICancelWriteCall {
+func (c *MockStreamICancelWriteCall) DoAndReturn(f func(StreamErrorCode)) *MockStreamICancelWriteCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }
@@ -347,10 +346,10 @@ func (c *MockStreamISetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *
 }
 
 // StreamID mocks base method.
-func (m *MockStreamI) StreamID() protocol.StreamID {
+func (m *MockStreamI) StreamID() StreamID {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StreamID")
-	ret0, _ := ret[0].(protocol.StreamID)
+	ret0, _ := ret[0].(StreamID)
 	return ret0
 }
 
@@ -367,19 +366,19 @@ type MockStreamIStreamIDCall struct {
 }
 
 // Return rewrite *gomock.Call.Return
-func (c *MockStreamIStreamIDCall) Return(arg0 protocol.StreamID) *MockStreamIStreamIDCall {
+func (c *MockStreamIStreamIDCall) Return(arg0 StreamID) *MockStreamIStreamIDCall {
 	c.Call = c.Call.Return(arg0)
 	return c
 }
 
 // Do rewrite *gomock.Call.Do
-func (c *MockStreamIStreamIDCall) Do(f func() protocol.StreamID) *MockStreamIStreamIDCall {
+func (c *MockStreamIStreamIDCall) Do(f func() StreamID) *MockStreamIStreamIDCall {
 	c.Call = c.Call.Do(f)
 	return c
 }
 
 // DoAndReturn rewrite *gomock.Call.DoAndReturn
-func (c *MockStreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *MockStreamIStreamIDCall {
+func (c *MockStreamIStreamIDCall) DoAndReturn(f func() StreamID) *MockStreamIStreamIDCall {
 	c.Call = c.Call.DoAndReturn(f)
 	return c
 }