linting the code

wrappers/packetack/client_abridged.go

@@ -26,9 +26,11 @@ func (w *wrapperClientAbridged) Read(acks *conntypes.ConnectionAcks) (conntypes.
 	buf := bytes.Buffer{}
 
 	buf.Grow(1)
+
 	if _, err := io.CopyN(&buf, w.parent, 1); err != nil {
 		return nil, fmt.Errorf("cannot read message length: %w", err)
 	}
+
 	msgLength := uint32(buf.Bytes()[0])
 	buf.Reset()
 
@@ -39,17 +41,21 @@ func (w *wrapperClientAbridged) Read(acks *conntypes.ConnectionAcks) (conntypes.
 
 	if msgLength == clientAbridgedSmallPacketLength {
 		buf.Grow(3)
+
 		if _, err := io.CopyN(&buf, w.parent, 3); err != nil {
 			return nil, fmt.Errorf("cannot read correct message length: %w", err)
 		}
+
 		number := utils.Uint24{}
 		copy(number[:], buf.Bytes())
 		msgLength = utils.FromUint24(number)
 	}
+
 	msgLength *= 4
 
 	buf.Reset()
 	buf.Grow(int(msgLength))
+
 	if _, err := io.CopyN(&buf, w.parent, int64(msgLength)); err != nil {
 		return nil, fmt.Errorf("cannot read message: %w", err)
 	}
@@ -66,18 +72,20 @@ func (w *wrapperClientAbridged) Write(packet conntypes.Packet, acks *conntypes.C
 		if _, err := w.parent.Write(utils.ReverseBytes(packet)); err != nil {
 			return fmt.Errorf("cannot send a simpleacked packet: %w", err)
 		}
+
 		return nil
 	}
 
 	packetLength := len(packet) / 4
+
 	switch {
 	case packetLength < clientAbridgedSmallPacketLength:
 		data := append([]byte{byte(packetLength)}, packet...)
 		if _, err := w.parent.Write(data); err != nil {
 			return fmt.Errorf("cannot send small packet: %w", err)
 		}
-		return nil
 
+		return nil
 	case packetLength < clientAbridgedLargePacketLength:
 		length24 := utils.ToUint24(uint32(packetLength))
 		buf := bytes.Buffer{}
@@ -89,6 +97,7 @@ func (w *wrapperClientAbridged) Write(packet conntypes.Packet, acks *conntypes.C
 		if _, err := w.parent.Write(buf.Bytes()); err != nil {
 			return fmt.Errorf("cannot send large packet: %w", err)
 		}
+
 		return nil
 	}
 

wrappers/packetack/client_intermediate.go

@@ -22,9 +22,11 @@ func (w *wrapperClientIntermediate) Read(acks *conntypes.ConnectionAcks) (connty
 	buf := bytes.Buffer{}
 
 	buf.Grow(4)
+
 	if _, err := io.CopyN(&buf, w.parent, 4); err != nil {
 		return nil, fmt.Errorf("cannot read message length: %w", err)
 	}
+
 	length := binary.LittleEndian.Uint32(buf.Bytes())
 
 	if length > clientIntermediateQuickAckLength {
@@ -34,6 +36,7 @@ func (w *wrapperClientIntermediate) Read(acks *conntypes.ConnectionAcks) (connty
 
 	buf.Reset()
 	buf.Grow(int(length))
+
 	if _, err := io.CopyN(&buf, w.parent, int64(length)); err != nil {
 		return nil, fmt.Errorf("cannot read the message: %w", err)
 	}
@@ -46,6 +49,7 @@ func (w *wrapperClientIntermediate) Write(packet conntypes.Packet, acks *conntyp
 		if _, err := w.parent.Write(packet); err != nil {
 			return fmt.Errorf("cannot send simpleacked packet: %w", err)
 		}
+
 		return nil
 	}
 
@@ -55,6 +59,7 @@ func (w *wrapperClientIntermediate) Write(packet conntypes.Packet, acks *conntyp
 	if _, err := w.parent.Write(append(length[:], packet...)); err != nil {
 		return fmt.Errorf("cannot send packet: %w", err)
 	}
+
 	return nil
 }
 

wrappers/packetack/client_intermediate_secure.go

@@ -20,6 +20,7 @@ func (w *wrapperClientIntermediateSecure) Read(acks *conntypes.ConnectionAcks) (
 	if err != nil {
 		return nil, err
 	}
+
 	length := len(data) - (len(data) % 4)
 
 	return data[:length], nil
@@ -30,6 +31,7 @@ func (w *wrapperClientIntermediateSecure) Write(packet conntypes.Packet, acks *c
 		if _, err := w.parent.Write(packet); err != nil {
 			return fmt.Errorf("cannot send simpleacked packet: %w", err)
 		}
+
 		return nil
 	}
 
@@ -37,13 +39,14 @@ func (w *wrapperClientIntermediateSecure) Write(packet conntypes.Packet, acks *c
 	paddingLength := rand.Intn(4)
 	buf.Grow(4 + len(packet) + paddingLength)
 
-	binary.Write(&buf, binary.LittleEndian, uint32(len(packet)+paddingLength))
+	binary.Write(&buf, binary.LittleEndian, uint32(len(packet)+paddingLength)) // nolint: errcheck
 	buf.Write(packet)
 	buf.Write(make([]byte, paddingLength))
 
 	if _, err := w.parent.Write(buf.Bytes()); err != nil {
 		return fmt.Errorf("cannot send packet: %w", err)
 	}
+
 	return nil
 }
 

wrappers/packetack/proxy.go

@@ -15,12 +15,12 @@ import (
 )
 
 type wrapperProxy struct {
-	flags        rpc.ProxyRequestFlags
 	request      *protocol.TelegramRequest
 	clientIPPort []byte
 	ourIPPort    []byte
 	channelRead  hub.ChannelReadCloser
 	closeOnce    sync.Once
+	flags        rpc.ProxyRequestFlags
 }
 
 func (w *wrapperProxy) Write(packet conntypes.Packet, acks *conntypes.ConnectionAcks) error {
@@ -30,6 +30,7 @@ func (w *wrapperProxy) Write(packet conntypes.Packet, acks *conntypes.Connection
 	if acks.Quick {
 		flags |= rpc.ProxyRequestFlagsQuickAck
 	}
+
 	if bytes.HasPrefix(packet, rpc.ProxyRequestFlagsEncryptedPrefix[:]) {
 		flags |= rpc.ProxyRequestFlagsEncrypted
 	}
@@ -67,6 +68,7 @@ func (w *wrapperProxy) Close() error {
 		w.channelRead.Close()
 		hub.Registry.Unregister(w.request.ConnID)
 	})
+
 	return nil
 }