linting the code

mtproto/protocol.go

@@ -20,6 +20,7 @@ func TelegramProtocol(req *protocol.TelegramRequest) (conntypes.PacketReadWriteC
 
 	rpcNonceConn := packet.NewMtprotoFrame(conn, rpc.SeqNoNonce)
 	rpcNonceReq, err := doRPCNonceRequest(rpcNonceConn)
+
 	if err != nil {
 		return nil, fmt.Errorf("cannot do nonce request: %w", err)
 	}
@@ -35,6 +36,7 @@ func TelegramProtocol(req *protocol.TelegramRequest) (conntypes.PacketReadWriteC
 	if err := doRPCHandshakeRequest(frameConn); err != nil {
 		return nil, fmt.Errorf("cannot do handshake request: %w", err)
 	}
+
 	if err := getRPCHandshakeResponse(frameConn); err != nil {
 		return nil, fmt.Errorf("cannot get handshake response: %w", err)
 	}
@@ -42,11 +44,12 @@ func TelegramProtocol(req *protocol.TelegramRequest) (conntypes.PacketReadWriteC
 	return frameConn, nil
 }
 
-func doRPCNonceRequest(conn conntypes.PacketWriter) (*rpc.NonceRequest, error) {
+func doRPCNonceRequest(conn conntypes.BasePacketWriter) (*rpc.NonceRequest, error) {
 	rpcNonceReq, err := rpc.NewNonceRequest(telegram.Middle.Secret())
 	if err != nil {
 		panic(err)
 	}
+
 	if err := conn.Write(rpcNonceReq.Bytes()); err != nil {
 		return nil, err
 	}
@@ -54,7 +57,7 @@ func doRPCNonceRequest(conn conntypes.PacketWriter) (*rpc.NonceRequest, error) {
 	return rpcNonceReq, nil
 }
 
-func getRPCNonceResponse(conn conntypes.PacketReader, req *rpc.NonceRequest) (*rpc.NonceResponse, error) {
+func getRPCNonceResponse(conn conntypes.BasePacketReader, req *rpc.NonceRequest) (*rpc.NonceResponse, error) {
 	packet, err := conn.Read()
 	if err != nil {
 		return nil, fmt.Errorf("cannot read from connection: %w", err)
@@ -62,8 +65,9 @@ func getRPCNonceResponse(conn conntypes.PacketReader, req *rpc.NonceRequest) (*r
 
 	resp, err := rpc.NewNonceResponse(packet)
 	if err != nil {
-		return nil, fmt.Errorf("cannot build rpc nonce responce: %w", err)
+		return nil, fmt.Errorf("cannot build rpc nonce response: %w", err)
 	}
+
 	if err = resp.Valid(req); err != nil {
 		return nil, fmt.Errorf("invalid nonce response: %w", err)
 	}
@@ -71,14 +75,15 @@ func getRPCNonceResponse(conn conntypes.PacketReader, req *rpc.NonceRequest) (*r
 	return resp, nil
 }
 
-func doRPCHandshakeRequest(conn conntypes.PacketWriter) error {
+func doRPCHandshakeRequest(conn conntypes.BasePacketWriter) error {
 	if err := conn.Write(rpc.HandshakeRequest); err != nil {
 		return fmt.Errorf("cannot make a request: %w", err)
 	}
+
 	return nil
 }
 
-func getRPCHandshakeResponse(conn conntypes.PacketReader) error {
+func getRPCHandshakeResponse(conn conntypes.BasePacketReader) error {
 	packet, err := conn.Read()
 	if err != nil {
 		return fmt.Errorf("cannot read a response: %w", err)
@@ -88,6 +93,7 @@ func getRPCHandshakeResponse(conn conntypes.PacketReader) error {
 	if err != nil {
 		return fmt.Errorf("cannot build a handshake response: %w", err)
 	}
+
 	if err := resp.Valid(); err != nil {
 		return fmt.Errorf("invalid handshake response: %w", err)
 	}

mtproto/rpc/handshake_response.go

@@ -28,10 +28,11 @@ func (r *HandshakeResponse) Bytes() []byte {
 // Valid checks that handshake response compliments request.
 func (r *HandshakeResponse) Valid() error {
 	if !bytes.Equal(r.Type, TagHandshake) {
-		return errors.New("Unexpected handshake tag")
+		return errors.New("unexpected handshake tag")
 	}
+
 	if !bytes.Equal(r.PeerPID, HandshakeSenderPID) {
-		return errors.New("Incorrect sender PID")
+		return errors.New("incorrect sender PID")
 	}
 
 	return nil
@@ -41,7 +42,7 @@ func (r *HandshakeResponse) Valid() error {
 // data.
 func NewHandshakeResponse(data []byte) (*HandshakeResponse, error) {
 	if len(data) != 32 {
-		return nil, fmt.Errorf("Incorrect handshake response length %d", len(data))
+		return nil, fmt.Errorf("incorrect handshake response length %d", len(data))
 	}
 
 	return &HandshakeResponse{

mtproto/rpc/nonce_request.go

@@ -36,6 +36,7 @@ func NewNonceRequest(proxySecret []byte) (*NonceRequest, error) {
 	if _, err := rand.Read(nonce); err != nil {
 		return nil, fmt.Errorf("cannot generate nonce: %w", err)
 	}
+
 	copy(keySelector, proxySecret)
 
 	timestamp := time.Now().Truncate(time.Second).Unix() % 4294967296 // 256 ^ 4 - do not know how to name

mtproto/rpc/nonce_response.go

@@ -28,13 +28,15 @@ func (r *NonceResponse) Bytes() []byte {
 
 func (r *NonceResponse) Valid(req *NonceRequest) error {
 	if !bytes.Equal(r.Type, TagNonce) {
-		return errors.New("Unexpected RPC type")
+		return errors.New("unexpected RPC type")
 	}
+
 	if !bytes.Equal(r.Crypto, NonceCryptoAES) {
-		return errors.New("Unexpected crypto type")
+		return errors.New("unexpected crypto type")
 	}
+
 	if !bytes.Equal(r.KeySelector, req.KeySelector) {
-		return errors.New("Unexpected key selector")
+		return errors.New("unexpected key selector")
 	}
 
 	return nil
@@ -43,7 +45,7 @@ func (r *NonceResponse) Valid(req *NonceRequest) error {
 // NewNonceResponse build new nonce response based on the given data.
 func NewNonceResponse(data []byte) (*NonceResponse, error) {
 	if len(data) != 32 {
-		return nil, fmt.Errorf("Unexpected message length %d", len(data))
+		return nil, fmt.Errorf("unexpected message length %d", len(data))
 	}
 
 	return &NonceResponse{

mtproto/rpc/proxy_flags.go

@@ -33,24 +33,31 @@ func (r ProxyRequestFlags) String() string {
 	if r&ProxyRequestFlagsHasAdTag != 0 {
 		flags = append(flags, "HAS_AD_TAG")
 	}
+
 	if r&ProxyRequestFlagsEncrypted != 0 {
 		flags = append(flags, "ENCRYPTED")
 	}
+
 	if r&ProxyRequestFlagsMagic != 0 {
 		flags = append(flags, "MAGIC")
 	}
+
 	if r&ProxyRequestFlagsExtMode2 != 0 {
 		flags = append(flags, "EXT_MODE_2")
 	}
+
 	if r&ProxyRequestFlagsIntermediate != 0 {
 		flags = append(flags, "INTERMEDIATE")
 	}
+
 	if r&ProxyRequestFlagsAbdridged != 0 {
 		flags = append(flags, "ABRIDGED")
 	}
+
 	if r&ProxyRequestFlagsQuickAck != 0 {
 		flags = append(flags, "QUICK_ACK")
 	}
+
 	if r&ProxyRequestFlagsPad != 0 {
 		flags = append(flags, "PAD")
 	}

mtproto/rpc/proxy_response.go

@@ -29,21 +29,23 @@ func ParseProxyResponse(packet conntypes.Packet) (*ProxyResponse, error) {
 	}
 
 	tag := packet[:4]
+
 	switch {
 	case bytes.Equal(tag, TagProxyAns):
 		response.Type = ProxyResponseTypeAns
 		copy(response.ConnID[:], packet[8:16])
 		response.Payload = packet[16:]
-		return &response, nil
 
+		return &response, nil
 	case bytes.Equal(tag, TagSimpleAck):
 		response.Type = ProxyResponseTypeSimpleAck
 		copy(response.ConnID[:], packet[4:12])
 		response.Payload = packet[12:]
-		return &response, nil
 
+		return &response, nil
 	case bytes.Equal(tag, TagCloseExt):
 		response.Type = ProxyResponseTypeCloseExt
+
 		return &response, nil
 	}