aggressive lint

Author: dvush

.golangci.yaml

@@ -1,5 +1,5 @@
 linters:
-  enable-all: false
+  enable-all: true
   disable:
     - cyclop
     - forbidigo
@@ -28,6 +28,9 @@ linters:
     - exhaustruct
     - depguard
     - err113
+    - gocognit
+    - nakedret
+    - tagliatelle
 
     #
     # Disabled because of generics:
@@ -55,11 +58,6 @@ linters-settings:
     excludes:
       - G108
 
-  tagliatelle:
-    case:
-      rules:
-        json: snake
-
   gofumpt:
     extra-rules: true
 

cmd/receiver-proxy/main.go

@@ -53,7 +53,7 @@ var flags []cli.Flag = []cli.Flag{
 	&cli.StringFlag{
 		Name:    "builder-confighub-endpoint",
 		Value:   "http://127.0.0.1:14892",
-		Usage:   "address of the builder config hub enpoint (directly or throught the cvm-proxy)",
+		Usage:   "address of the builder config hub enpoint (directly or using the cvm-proxy)",
 		EnvVars: []string{"BUILDER_CONFIGHUB_ENDPOINT"},
 	},
 	&cli.StringFlag{

cmd/sender-proxy/main.go

@@ -28,7 +28,7 @@ var flags []cli.Flag = []cli.Flag{
 	&cli.StringFlag{
 		Name:    "builder-confighub-endpoint",
 		Value:   "http://127.0.0.1:14892",
-		Usage:   "address of the builder config hub enpoint (directly or throught the cvm-proxy)",
+		Usage:   "address of the builder config hub enpoint (directly or using the cvm-proxy)",
 		EnvVars: []string{"BUILDER_CONFIGHUB_ENDPOINT"},
 	},
 	&cli.StringFlag{

proxy/archive.go

@@ -39,13 +39,13 @@ type ArchiveQueue struct {
 }
 
 func (aq *ArchiveQueue) Run() {
-	var workers []*archiveQueueWorker
 	workerCount := 1
 	if aq.workerCount > 0 {
 		workerCount = aq.workerCount
 	}
+	workers := make([]*archiveQueueWorker, 0, workerCount)
 	workersQueue := make(chan *ParsedRequest, ArchiveWorkerQueueSize)
-	for w := 0; w < workerCount; w++ {
+	for w := range workerCount {
 		worker := &archiveQueueWorker{
 			log:           aq.log.With(slog.Int("worker", w)),
 			archiveClient: aq.archiveClient,

proxy/confighub.go

@@ -74,7 +74,7 @@ func (b *BuilderConfigHub) Builders(internal bool) (result []ConfighubBuilder, e
 	} else {
 		url += "/api/l1-builder/v1/builders"
 	}
-	resp, err = http.Get(url)
+	resp, err = http.Get(url) //nolint:gosec
 	if err != nil {
 		return
 	}

proxy/receiver_proxy.go

@@ -134,7 +134,7 @@ func NewReceiverProxy(config ReceiverProxyConfig) (*ReceiverProxy, error) {
 
 	prx.CertHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Add("Content-Type", "application/octet-stream")
-		_, err := w.Write([]byte(prx.PublicCertPEM))
+		_, err := w.Write(prx.PublicCertPEM)
 		if err != nil {
 			prx.Log.Warn("Failed to serve certificate", slog.Any("error", err))
 		}

proxy/receiver_proxy_test.go

@@ -77,28 +77,28 @@ func StartTestOrderflowProxy(name string) (*OrderflowProxyTestSetup, error) {
 	localBuilderServer := ServeHTTPRequestToChan(localBuilderRequests)
 
 	proxy := createProxy(localBuilderServer.URL, name)
-	publicProxyServer := &http.Server{
+	publicProxyServer := &http.Server{ //nolint:gosec
 		Handler:   proxy.PublicHandler,
 		TLSConfig: proxy.TLSConfig(),
 	}
-	publicListener, err := net.Listen("tcp", ":0")
+	publicListener, err := net.Listen("tcp", ":0") //nolint:gosec
 	if err != nil {
 		return nil, err
 	}
-	go publicProxyServer.ServeTLS(publicListener, "", "") //nolint: errcheck
-	publicServerEndpoint := fmt.Sprintf("https://localhost:%d", publicListener.Addr().(*net.TCPAddr).Port)
-	ip := fmt.Sprintf("127.0.0.1:%d", publicListener.Addr().(*net.TCPAddr).Port)
+	go publicProxyServer.ServeTLS(publicListener, "", "")                                                  //nolint: errcheck
+	publicServerEndpoint := fmt.Sprintf("https://localhost:%d", publicListener.Addr().(*net.TCPAddr).Port) //nolint:forcetypeassert
+	ip := fmt.Sprintf("127.0.0.1:%d", publicListener.Addr().(*net.TCPAddr).Port)                           //nolint:forcetypeassert
 
-	localProxyServer := &http.Server{
+	localProxyServer := &http.Server{ //nolint:gosec
 		Handler:   proxy.LocalHandler,
 		TLSConfig: proxy.TLSConfig(),
 	}
-	localListener, err := net.Listen("tcp", ":0")
+	localListener, err := net.Listen("tcp", ":0") //nolint:gosec
 	if err != nil {
 		return nil, err
 	}
-	go localProxyServer.ServeTLS(localListener, "", "") //nolint:errcheck
-	localServerEndpoint := fmt.Sprintf("https://localhost:%d", localListener.Addr().(*net.TCPAddr).Port)
+	go localProxyServer.ServeTLS(localListener, "", "")                                                  //nolint:errcheck
+	localServerEndpoint := fmt.Sprintf("https://localhost:%d", localListener.Addr().(*net.TCPAddr).Port) //nolint:forcetypeassert
 
 	certProxyServer := httptest.NewServer(proxy.CertHandler)
 
@@ -160,7 +160,7 @@ func TestMain(m *testing.M) {
 	archiveServer = ServeHTTPRequestToChan(archiveServerRequests)
 	defer archiveServer.Close()
 
-	for i := 0; i < 3; i++ {
+	for i := range 3 {
 		proxy, err := StartTestOrderflowProxy(fmt.Sprintf("proxy:%d", i))
 		proxies = append(proxies, proxy)
 		if err != nil {
@@ -233,6 +233,7 @@ func expectNoRequest(t *testing.T, ch chan *RequestData) {
 }
 
 func proxiesUpdatePeers(t *testing.T) {
+	t.Helper()
 	for _, instance := range proxies {
 		err := instance.proxy.RequestNewPeers()
 		require.NoError(t, err)

proxy/sharing.go

@@ -64,7 +64,7 @@ func (sq *ShareQueue) Run() {
 	if sq.localBuilder != nil {
 		builderPeer := newShareQueuePeer("local-builder", sq.localBuilder)
 		localBuilder = &builderPeer
-		for worker := 0; worker < workersPerPeer; worker += 1 {
+		for worker := range workersPerPeer {
 			go sq.proxyRequests(localBuilder, worker)
 		}
 		defer localBuilder.Close()
@@ -108,7 +108,7 @@ func (sq *ShareQueue) Run() {
 				sq.log.Info("Created client for peer", slog.String("peer", info.Name), slog.String("name", sq.name))
 				newPeer := newShareQueuePeer(info.Name, client)
 				peers = append(peers, newPeer)
-				for worker := 0; worker < workersPerPeer; worker += 1 {
+				for worker := range workersPerPeer {
 					go sq.proxyRequests(&newPeer, worker)
 				}
 			}
@@ -155,7 +155,7 @@ func (sq *ShareQueue) proxyRequests(peer *shareQueuePeer, worker int) {
 		ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
 		resp, err := peer.client.Call(ctx, method, data)
 		cancel()
-		timeShareQueuePeerRPCDuration(peer.name, int64(time.Since(start).Milliseconds()))
+		timeShareQueuePeerRPCDuration(peer.name, time.Since(start).Milliseconds())
 		if err != nil {
 			logger.Warn("Error while proxying request", slog.Any("error", err))
 			incShareQueuePeerRPCErrors(peer.name)

proxy/utils.go

@@ -5,7 +5,7 @@ import (
 	"crypto/tls"
 	"crypto/x509"
 	"errors"
-	"fmt"
+	"net"
 	"net/http"
 	"strings"
 	"sync"
@@ -16,7 +16,7 @@ import (
 	"github.com/flashbots/go-utils/signature"
 )
 
-var DefaultOrderflowProxyPublicPort = 5544
+var DefaultOrderflowProxyPublicPort = "5544"
 
 var errCertificate = errors.New("failed to add certificate to pool")
 
@@ -27,7 +27,8 @@ func createTransportForSelfSignedCert(certPEM []byte) (*http.Transport, error) {
 	}
 	return &http.Transport{
 		TLSClientConfig: &tls.Config{
-			RootCAs: certPool,
+			RootCAs:    certPool,
+			MinVersion: tls.VersionTLS12,
 		},
 	}, nil
 }
@@ -41,7 +42,7 @@ func HTTPClientWithMaxConnections(maxOpenConnections int) *http.Client {
 	}
 }
 
-func RPCClientWithCertAndSigner(endpoint string, certPEM []byte, signer *signature.Signer, maxOpenConnections int) (rpcclient.RPCClient, error) {
+func RPCClientWithCertAndSigner(endpoint string, certPEM []byte, signer *signature.Signer, maxOpenConnections int) (rpcclient.RPCClient, error) { //nolint:ireturn
 	transport, err := createTransportForSelfSignedCert(certPEM)
 	if err != nil {
 		return nil, err
@@ -59,9 +60,9 @@ func RPCClientWithCertAndSigner(endpoint string, certPEM []byte, signer *signatu
 
 func OrderflowProxyURLFromIP(ip string) string {
 	if strings.Contains(ip, ":") {
-		return fmt.Sprintf("https://%s", ip)
+		return "https://" + ip
 	} else {
-		return fmt.Sprintf("https://%s:%d", ip, DefaultOrderflowProxyPublicPort)
+		return "https://" + net.JoinHostPort(ip, DefaultOrderflowProxyPublicPort)
 	}
 }