cmd/utils/app: process all files passed to import command (erigontech#21513)

## Problem

The Hive `legacy-cancun` BlockchainTests suite intermittently fails 4
tests with `client did not start: timed out waiting for container
startup`:

- `walletReorganizeOwners_{Cancun,Istanbul,London,Paris}`

(e.g. [this
run](https://hive.ethpandaops.io/#/test/generic/1779833679-c7f17208e0b5dbf959b3448bbdaed60e)).
They took ~181s, just over Hive's 180s container-startup timeout. The
same test on other forks (Shanghai/Berlin) and `ForkStressTest_*` sit at
146–150s — right at the cliff.

## Root cause

The `import` command documents multi-file support:

```
USAGE: erigon import [command options] <filename> (<filename 2> ... <filename N>)
```

but `importChain` only processed `cliCtx.Args().First()`, silently
ignoring the rest. That forced Hive's erigon entrypoint into a
one-process-per-block-file loop. For `walletReorganizeOwners` (235 block
files) that is 235 full erigon startups — measured at ~0.5s/process ×
261 = 145s of pure startup, while actual block execution is ~40ms each.
go-ethereum has no such problem: its entrypoint imports every block in
one `geth import` invocation.

## Fix

Iterate every file argument in a single process, tolerating per-file
failures when several files are given (matching go-ethereum). This lets
the hive entrypoint import all blocks in one invocation, collapsing
hundreds of process startups into one (~150s → ~10s).

It also force-disables the embedded MCP server for the one-shot import
(`--mcp.disable`, alongside the existing NAT / downloader /
external-consensus disables) — a batch import has no use for it.

## Companion change (required)

The hive entrypoint must pass all block files in one invocation:
ethereum/hive#1519. Order matters — the hive change depends on this one
(on an old erigon, `import /blocks/*` would import only the first
block).

## Testing

- New unit tests (`import_cmd_test.go`): all-files iteration, per-file
failure tolerance, single-file error surfacing.
- Real-binary check: `erigon import a.rlp b.rlp` now attempts **both**
files in one process (previously stopped after the first).
- `make lint` clean; `make erigon integration` builds.

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-authored-by: Giulio Rebuffo <111551070+Giulio2002@users.noreply.github.com>

Author: 3 people

cmd/utils/app/import_cmd.go

@@ -54,6 +54,8 @@ const (
 	importBatchSize = 2500
 )
 
+var errInterrupted = errors.New("interrupted")
+
 var importCommand = cli.Command{
 	Action:    MigrateFlags(importChain),
 	Name:      "import",
@@ -87,6 +89,7 @@ func importChain(cliCtx *cli.Context) error {
 		utils.NATFlag.Name:               "none",
 		utils.NoDownloaderFlag.Name:      "true",
 		utils.ExternalConsensusFlag.Name: "true",
+		utils.MCPDisableFlag.Name:        "true",
 	} {
 		if err := cliCtx.Set(flag, value); err != nil {
 			return fmt.Errorf("importChain: set %s=%s: %w", flag, value, err)
@@ -116,11 +119,28 @@ func importChain(cliCtx *cli.Context) error {
 		return err
 	}
 
-	if err := ImportChain(ethereum, ethereum.ChainDB(), cliCtx.Args().First(), logger); err != nil {
-		return err
-	}
+	return importFiles(cliCtx.Args().Slice(), logger, func(fn string) error {
+		return ImportChain(ethereum, ethereum.ChainDB(), fn, logger)
+	})
+}
 
-	return nil
+// importFiles imports each file in order; with more than one file, per-file
+// failures are logged and skipped (matching go-ethereum), except a user
+// interrupt aborts the whole command.
+func importFiles(files []string, logger log.Logger, importOne func(fn string) error) error {
+	var importErr error
+	for _, fn := range files {
+		if err := importOne(fn); err != nil {
+			importErr = err
+			if errors.Is(err, errInterrupted) {
+				return err
+			}
+			if len(files) > 1 {
+				logger.Error("Import error", "file", fn, "err", err)
+			}
+		}
+	}
+	return importErr
 }
 
 func ImportChain(ethereum *eth.Ethereum, chainDB kv.RwDB, fn string, logger log.Logger) error {
@@ -169,7 +189,7 @@ func ImportChain(ethereum *eth.Ethereum, chainDB kv.RwDB, fn string, logger log.
 	for batch := 0; ; batch++ {
 		// Load a batch of RLP blocks.
 		if checkInterrupt() {
-			return errors.New("interrupted")
+			return errInterrupted
 		}
 		i := 0
 		for ; i < importBatchSize; i++ {
@@ -192,7 +212,7 @@ func ImportChain(ethereum *eth.Ethereum, chainDB kv.RwDB, fn string, logger log.
 		}
 		// Import the batch.
 		if checkInterrupt() {
-			return errors.New("interrupted")
+			return errInterrupted
 		}
 
 		br, _ := ethereum.BlockIO()

cmd/utils/app/import_cmd_test.go

@@ -0,0 +1,74 @@
+// Copyright 2026 The Erigon Authors
+// This file is part of Erigon.
+//
+// Erigon is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Erigon is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with Erigon. If not, see <http://www.gnu.org/licenses/>.
+
+package app
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/erigontech/erigon/common/log/v3"
+)
+
+func TestImportFilesProcessesEveryFile(t *testing.T) {
+	files := []string{"0001.rlp", "0002.rlp", "0003.rlp"}
+	var imported []string
+	err := importFiles(files, log.Root(), func(fn string) error {
+		imported = append(imported, fn)
+		return nil
+	})
+	require.NoError(t, err)
+	require.Equal(t, files, imported)
+}
+
+func TestImportFilesContinuesPastPerFileFailure(t *testing.T) {
+	files := []string{"0001.rlp", "0002.rlp", "0003.rlp"}
+	badBlock := errors.New("invalid block")
+	var imported []string
+	err := importFiles(files, log.Root(), func(fn string) error {
+		imported = append(imported, fn)
+		if fn == "0002.rlp" {
+			return badBlock
+		}
+		return nil
+	})
+	require.ErrorIs(t, err, badBlock)
+	require.Equal(t, files, imported, "a failing block file must not stop import of later files")
+}
+
+func TestImportFilesSingleFileSurfacesError(t *testing.T) {
+	badBlock := errors.New("invalid block")
+	err := importFiles([]string{"0001.rlp"}, log.Root(), func(fn string) error {
+		return badBlock
+	})
+	require.ErrorIs(t, err, badBlock)
+}
+
+func TestImportFilesStopsOnInterrupt(t *testing.T) {
+	files := []string{"0001.rlp", "0002.rlp", "0003.rlp"}
+	var imported []string
+	err := importFiles(files, log.Root(), func(fn string) error {
+		imported = append(imported, fn)
+		if fn == "0002.rlp" {
+			return errInterrupted
+		}
+		return nil
+	})
+	require.ErrorIs(t, err, errInterrupted)
+	require.Equal(t, []string{"0001.rlp", "0002.rlp"}, imported, "user interrupt must abort the whole import, not just skip the current file")
+}