chore: add stricter linting

.github/workflows/lint.yml

@@ -29,7 +29,7 @@ jobs:
       - uses: golangci/golangci-lint-action@v9.2.0
         with:
           version: latest
-          args: --timeout 10m
+          args: --timeout 10m ./...
           github-token: ${{ secrets.github_token }}
         if: env.GIT_DIFF
 

.golangci.yml

@@ -1,18 +1,63 @@
 version: "2"
 run:
   modules-download-mode: readonly
+  timeout: 10m
+  tests: true
   build-tags:
     - evm
     - e2e
     - docker
 linters:
   enable:
+    - asciicheck
+    - bidichk
+    - bodyclose
+    - containedctx
+    - contextcheck
+    - copyloopvar
+    - durationcheck
+    - errname
+    - errcheck
     - errorlint
+    - gocritic
+    - govet
+    - ineffassign
+    - makezero
     - gosec
     - misspell
+    - nilerr
+    - noctx
+    - nolintlint
+    - prealloc
+    - predeclared
+    - reassign
     - revive
+    - rowserrcheck
+    - sqlclosecheck
+    - staticcheck
+    - testifylint
     - unconvert
+    - unparam
+    - unused
+    - usestdlibvars
+    - wastedassign
   settings:
+    errcheck:
+      check-type-assertions: true
+      check-blank: true
+    govet:
+      enable-all: true
+      disable:
+        - fieldalignment
+        - shadow
+    gocritic:
+      enabled-tags:
+        - diagnostic
+        - style
+        - performance
+      disabled-checks:
+        - hugeParam
+        - rangeValCopy
     gosec:
       excludes:
         - G115
@@ -21,7 +66,7 @@ linters:
         - name: package-comments
           disabled: true
         - name: duplicated-imports
-          severity: warning
+          severity: error
         - name: exported
           arguments:
             - disableStutteringCheck
@@ -32,10 +77,28 @@ linters:
       - common-false-positives
       - legacy
       - std-error-handling
+    rules:
+      - path: _test\.go
+        linters:
+          - prealloc
+          - noctx
     paths:
       - third_party$
       - builtin$
       - examples$
+  disable:
+    - containedctx
+    - errcheck
+    - gocritic
+    - nolintlint
+    - testifylint
+    - thelper
+    - tparallel
+    - unparam
+    - wrapcheck
+issues:
+  max-issues-per-linter: 0
+  max-same-issues: 0
 formatters:
   enable:
     - gci

.just/lint.just

@@ -2,7 +2,7 @@
 [group('lint')]
 lint: vet
     @echo "--> Running golangci-lint"
-    @golangci-lint run
+    @golangci-lint run ./...
     @echo "--> Running markdownlint"
     @markdownlint --config .markdownlint.yaml '**/*.md'
     @echo "--> Running hadolint"
@@ -18,7 +18,7 @@ lint: vet
 [group('lint')]
 lint-fix:
     @echo "--> Formatting go"
-    @golangci-lint run --fix
+    @golangci-lint run --fix ./...
     @echo "--> Formatting markdownlint"
     @markdownlint --config .markdownlint.yaml --ignore './changelog.md' '**/*.md' -f
 

block/internal/da/async_block_retriever_test.go

@@ -266,5 +266,6 @@ func TestBlockData_SerializationEmpty(t *testing.T) {
 	}
 
 	assert.Equal(t, uint64(100), decoded.Height)
+	assert.Equal(t, time.Unix(0, 0).UTC(), decoded.Timestamp)
 	assert.Equal(t, 0, len(decoded.Blobs))
 }

block/internal/executing/executor.go

@@ -591,7 +591,7 @@ func (e *Executor) ProduceBlock(ctx context.Context) error {
 			LastSubmittedDaHeaderHeight: e.cache.GetLastSubmittedHeaderHeight(),
 			LastSubmittedDaDataHeight:   e.cache.GetLastSubmittedDataHeight(),
 		}
-		if err := e.raftNode.Broadcast(e.ctx, raftState); err != nil {
+		if err := e.raftNode.Broadcast(ctx, raftState); err != nil {
 			return fmt.Errorf("failed to propose block to raft: %w", err)
 		}
 		e.logger.Debug().Uint64("height", newHeight).Msg("proposed block to raft")
@@ -617,12 +617,12 @@ func (e *Executor) ProduceBlock(ctx context.Context) error {
 	// IMPORTANT: Header MUST be broadcast before data — the P2P layer validates
 	// incoming data against the current and previous header, so out-of-order
 	// delivery would cause validation failures on peers.
-	if err := e.headerBroadcaster.WriteToStoreAndBroadcast(e.ctx, &types.P2PSignedHeader{
+	if err := e.headerBroadcaster.WriteToStoreAndBroadcast(ctx, &types.P2PSignedHeader{
 		SignedHeader: header,
 	}); err != nil {
 		e.logger.Error().Err(err).Msg("failed to broadcast header")
 	}
-	if err := e.dataBroadcaster.WriteToStoreAndBroadcast(e.ctx, &types.P2PData{
+	if err := e.dataBroadcaster.WriteToStoreAndBroadcast(ctx, &types.P2PData{
 		Data: data,
 	}); err != nil {
 		e.logger.Error().Err(err).Msg("failed to broadcast data")
@@ -637,7 +637,7 @@ func (e *Executor) ProduceBlock(ctx context.Context) error {
 
 	// For based sequencer, advance safe/finalized since it comes from DA.
 	if e.config.Node.BasedSequencer {
-		if err := e.exec.SetFinal(e.ctx, newHeight); err != nil {
+		if err := e.exec.SetFinal(ctx, newHeight); err != nil {
 			e.sendCriticalError(fmt.Errorf("failed to set final height in based sequencer mode: %w", err))
 			return fmt.Errorf("failed to set final height in based sequencer mode: %w", err)
 		}

block/internal/submitting/da_submitter.go

@@ -90,15 +90,15 @@ func (rs *retryState) Next(reason retryReason, pol retryPolicy) {
 }
 
 // clamp constrains a duration between min and max bounds
-func clamp(v, min, max time.Duration) time.Duration {
-	if min > max {
-		min, max = max, min
+func clamp(v, minTime, maxTime time.Duration) time.Duration {
+	if minTime > maxTime {
+		minTime, maxTime = maxTime, minTime
 	}
-	if v < min {
-		return min
+	if v < minTime {
+		return minTime
 	}
-	if v > max {
-		return max
+	if v > maxTime {
+		return maxTime
 	}
 	return v
 }

block/internal/submitting/da_submitter_test.go

@@ -145,7 +145,6 @@ func TestDASubmitter_SubmitHeaders_Success(t *testing.T) {
 
 	// Create test signer
 	addr, pub, signer := createTestSigner(t)
-	gen.ProposerAddress = addr
 
 	// Create test headers
 	header1 := &types.SignedHeader{

block/internal/syncing/syncer.go

@@ -178,14 +178,14 @@ func (s *Syncer) Start(ctx context.Context) error {
 
 	s.fiRetriever = da.NewForcedInclusionRetriever(s.daClient, s.logger, s.config, s.genesis.DAStartHeight, s.genesis.DAEpochForcedInclusion)
 	s.p2pHandler = NewP2PHandler(s.headerStore, s.dataStore, s.cache, s.genesis, s.logger)
-	if currentHeight, err := s.store.Height(s.ctx); err != nil {
+	if currentHeight, err := s.store.Height(ctx); err != nil {
 		s.logger.Error().Err(err).Msg("failed to set initial processed height for p2p handler")
 	} else {
 		s.p2pHandler.SetProcessedHeight(currentHeight)
 	}
 
 	if s.raftRetriever != nil {
-		if err := s.raftRetriever.Start(s.ctx); err != nil {
+		if err := s.raftRetriever.Start(ctx); err != nil {
 			return fmt.Errorf("start raft retriever: %w", err)
 		}
 	}
@@ -198,7 +198,7 @@ func (s *Syncer) Start(ctx context.Context) error {
 	s.wg.Go(s.processLoop)
 
 	// Start dedicated workers for DA, and pending processing
-	s.startSyncWorkers()
+	s.startSyncWorkers(ctx)
 
 	s.logger.Info().Msg("syncer started")
 	return nil
@@ -358,11 +358,12 @@ func (s *Syncer) processLoop() {
 	}
 }
 
-func (s *Syncer) startSyncWorkers() {
+func (s *Syncer) startSyncWorkers(ctx context.Context) {
+	_ = ctx
 	s.wg.Add(3)
 	go s.daWorkerLoop()
 	go s.pendingWorkerLoop()
-	go s.p2pWorkerLoop()
+	go s.p2pWorkerLoop(ctx)
 }
 
 func (s *Syncer) daWorkerLoop() {
@@ -485,7 +486,7 @@ func (s *Syncer) pendingWorkerLoop() {
 	}
 }
 
-func (s *Syncer) p2pWorkerLoop() {
+func (s *Syncer) p2pWorkerLoop(ctx context.Context) {
 	defer s.wg.Done()
 
 	logger := s.logger.With().Str("worker", "p2p").Logger()
@@ -494,12 +495,12 @@ func (s *Syncer) p2pWorkerLoop() {
 
 	for {
 		select {
-		case <-s.ctx.Done():
+		case <-ctx.Done():
 			return
 		default:
 		}
 
-		currentHeight, err := s.store.Height(s.ctx)
+		currentHeight, err := s.store.Height(ctx)
 		if err != nil {
 			logger.Error().Err(err).Msg("failed to get current height for P2P worker")
 			if !s.sleepOrDone(50 * time.Millisecond) {
@@ -509,7 +510,7 @@ func (s *Syncer) p2pWorkerLoop() {
 		}
 
 		targetHeight := currentHeight + 1
-		waitCtx, cancel := context.WithCancel(s.ctx)
+		waitCtx, cancel := context.WithCancel(ctx)
 		s.setP2PWaitState(targetHeight, cancel)
 
 		err = s.p2pHandler.ProcessHeight(waitCtx, targetHeight, s.heightInCh)
@@ -879,7 +880,7 @@ func (s *Syncer) ValidateBlock(_ context.Context, currState types.State, data *t
 	// Set custom verifier for aggregator node signature
 	header.SetCustomVerifierForSyncNode(s.options.SyncNodeSignatureBytesProvider)
 
-	if err := header.ValidateBasicWithData(data); err != nil {
+	if err := header.ValidateBasicWithData(data); err != nil { //nolint:contextcheck // validation API does not accept context
 		return fmt.Errorf("invalid header: %w", err)
 	}
 
@@ -1226,10 +1227,7 @@ func (s *Syncer) RecoverFromRaft(ctx context.Context, raftState *raft.RaftBlockS
 			s.logger.Debug().Err(err).Msg("no state in store, using genesis defaults for recovery")
 			currentState = types.State{
 				ChainID:         s.genesis.ChainID,
-				InitialHeight:   s.genesis.InitialHeight,
 				LastBlockHeight: s.genesis.InitialHeight - 1,
-				LastBlockTime:   s.genesis.StartTime,
-				DAHeight:        s.genesis.DAStartHeight,
 			}
 		}
 	}

block/internal/syncing/syncer_backoff_test.go

@@ -121,7 +121,7 @@ func TestSyncer_BackoffOnDAError(t *testing.T) {
 				}
 
 				// Run sync loop
-				syncer.startSyncWorkers()
+				syncer.startSyncWorkers(t.Context())
 				<-ctx.Done()
 				syncer.wg.Wait()
 
@@ -223,7 +223,7 @@ func TestSyncer_BackoffResetOnSuccess(t *testing.T) {
 		go syncer.processLoop()
 
 		// Run workers
-		syncer.startSyncWorkers()
+		syncer.startSyncWorkers(t.Context())
 		<-ctx.Done()
 		syncer.wg.Wait()
 
@@ -294,7 +294,7 @@ func TestSyncer_BackoffBehaviorIntegration(t *testing.T) {
 			Return(nil, datypes.ErrBlobNotFound).Once()
 
 		go syncer.processLoop()
-		syncer.startSyncWorkers()
+		syncer.startSyncWorkers(t.Context())
 		<-ctx.Done()
 		syncer.wg.Wait()
 

block/internal/syncing/syncer_benchmark_test.go

@@ -44,7 +44,7 @@ func BenchmarkSyncerIO(b *testing.B) {
 
 				// run both loops
 				go fixt.s.processLoop()
-				fixt.s.startSyncWorkers()
+				fixt.s.startSyncWorkers(b.Context())
 
 				require.Eventually(b, func() bool {
 					processedHeight, _ := fixt.s.store.Height(b.Context())

block/internal/syncing/syncer_test.go

@@ -417,7 +417,7 @@ func TestSyncLoopPersistState(t *testing.T) {
 		Return(nil, datypes.ErrHeightFromFuture)
 
 	go syncerInst1.processLoop()
-	syncerInst1.startSyncWorkers()
+	syncerInst1.startSyncWorkers(t.Context())
 	syncerInst1.wg.Wait()
 	requireEmptyChan(t, errorCh)
 
@@ -480,7 +480,7 @@ func TestSyncLoopPersistState(t *testing.T) {
 
 	// when it starts, it should fetch from the last height it stopped at
 	t.Log("sync workers on instance2 started")
-	syncerInst2.startSyncWorkers()
+	syncerInst2.startSyncWorkers(t.Context())
 	syncerInst2.wg.Wait()
 
 	t.Log("sync workers exited")

node/failover.go

@@ -182,7 +182,7 @@ func setupFailoverState(
 func (f *failoverState) Run(pCtx context.Context) (multiErr error) {
 	stopService := func(stoppable func(context.Context) error, name string) {
 		// parent context is cancelled already, so we need to create a new one
-		shutdownCtx, done := context.WithTimeout(context.Background(), 3*time.Second)
+		shutdownCtx, done := context.WithTimeout(context.WithoutCancel(pCtx), 3*time.Second)
 		defer done()
 
 		if err := stoppable(shutdownCtx); err != nil && !errors.Is(err, context.Canceled) {
@@ -192,7 +192,7 @@ func (f *failoverState) Run(pCtx context.Context) (multiErr error) {
 	cCtx, cancel := context.WithCancel(pCtx)
 	defer cancel()
 	wg, ctx := errgroup.WithContext(cCtx)
-	wg.Go(func() (rerr error) {
+	wg.Go(func() (rerr error) { //nolint:contextcheck // block components stop API does not accept context
 		defer func() {
 			if err := f.bc.Stop(); err != nil && !errors.Is(err, context.Canceled) {
 				rerr = errors.Join(rerr, fmt.Errorf("stopping block components: %w", err))
@@ -234,7 +234,7 @@ func (f *failoverState) Run(pCtx context.Context) (multiErr error) {
 
 	wg.Go(func() error {
 		defer func() {
-			shutdownCtx, done := context.WithTimeout(context.Background(), 3*time.Second)
+			shutdownCtx, done := context.WithTimeout(context.WithoutCancel(ctx), 3*time.Second)
 			defer done()
 			_ = f.rpcServer.Shutdown(shutdownCtx)
 		}()

node/full.go

@@ -307,7 +307,7 @@ func (n *FullNode) Run(parentCtx context.Context) error {
 	n.Logger.Info().Msg("halting full node and its sub services...")
 
 	// Use a timeout context to ensure shutdown doesn't hang
-	shutdownCtx, cancel := context.WithTimeout(context.Background(), 9*time.Second)
+	shutdownCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 9*time.Second)
 	defer cancel()
 
 	var shutdownMultiErr error // Variable to accumulate multiple errors