op-node: add FETCH_WITHDRAWAL_ROOT_FROM_STATE config var

op-node/flags/flags.go

@@ -141,6 +141,13 @@ var (
 		EnvVars:  prefixEnvVars("RPC_ADMIN_STATE"),
 		Category: OperationsCategory,
 	}
+	FetchWithdrawalRootFromState = &cli.BoolFlag{
+		Name:     "fetch-withdrawal-root-from-state",
+		Usage:    "Read withdrawal_storage_root (aka message passer storage root) from state trie (via execution layer) instead of the block header. Restores pre-Isthmus behavior, requires an archive EL client.",
+		Required: false,
+		EnvVars:  prefixEnvVars("FETCH_WITHDRAWAL_ROOT_FROM_STATE"),
+		Category: OperationsCategory,
+	}
 	L1TrustRPC = &cli.BoolFlag{
 		Name:     "l1.trustrpc",
 		Usage:    "Trust the L1 RPC, sync faster at risk of malicious/buggy RPC providing bad or inconsistent L1 data",
@@ -451,6 +458,7 @@ var optionalFlags = []cli.Flag{
 	BeaconCheckIgnore,
 	BeaconFetchAllSidecars,
 	SyncModeFlag,
+	FetchWithdrawalRootFromState,
 	RPCListenAddr,
 	RPCListenPort,
 	L1TrustRPC,

op-node/node/config.go

@@ -78,6 +78,7 @@ type Config struct {
 	AltDA altda.CLIConfig
 
 	IgnoreMissingPectraBlobSchedule bool
+	FetchWithdrawalRootFromState    bool
 }
 
 // ConductorRPCFunc retrieves the endpoint. The RPC may not immediately be available.

op-node/node/node.go

@@ -389,6 +389,8 @@ func (n *OpNode) initL2(ctx context.Context, cfg *Config) error {
 		return fmt.Errorf("failed to setup L2 execution-engine RPC client: %w", err)
 	}
 
+	rpcCfg.FetchWithdrawalRootFromState = cfg.FetchWithdrawalRootFromState
+
 	n.l2Source, err = sources.NewEngineClient(rpcClient, n.log, n.metrics.L2SourceCache, rpcCfg)
 	if err != nil {
 		return fmt.Errorf("failed to create Engine client: %w", err)

op-node/service.go

@@ -117,6 +117,7 @@ func NewConfig(ctx *cli.Context, log log.Logger) (*node.Config, error) {
 		AltDA: altda.ReadCLIConfig(ctx),
 
 		IgnoreMissingPectraBlobSchedule: ctx.Bool(flags.IgnoreMissingPectraBlobSchedule.Name),
+		FetchWithdrawalRootFromState:    ctx.Bool(flags.FetchWithdrawalRootFromState.Name),
 	}
 
 	if err := cfg.LoadPersisted(log); err != nil {

op-service/sources/l2_client.go

@@ -22,8 +22,9 @@ import (
 type L2ClientConfig struct {
 	EthClientConfig
 
-	L2BlockRefsCacheSize int
-	L1ConfigsCacheSize   int
+	L2BlockRefsCacheSize         int
+	L1ConfigsCacheSize           int
+	FetchWithdrawalRootFromState bool
 
 	RollupCfg *rollup.Config
 }
@@ -75,6 +76,8 @@ type L2Client struct {
 	// cache SystemConfig by L2 hash
 	// common.Hash -> eth.SystemConfig
 	systemConfigsCache *caching.LRUCache[common.Hash, eth.SystemConfig]
+
+	fetchWithdrawalRootFromState bool
 }
 
 var _ apis.L2EthExtendedClient = (*L2Client)(nil)
@@ -89,10 +92,11 @@ func NewL2Client(client client.RPC, log log.Logger, metrics caching.Metrics, con
 	}
 
 	return &L2Client{
-		EthClient:          ethClient,
-		rollupCfg:          config.RollupCfg,
-		l2BlockRefsCache:   caching.NewLRUCache[common.Hash, eth.L2BlockRef](metrics, "blockrefs", config.L2BlockRefsCacheSize),
-		systemConfigsCache: caching.NewLRUCache[common.Hash, eth.SystemConfig](metrics, "systemconfigs", config.L1ConfigsCacheSize),
+		EthClient:                    ethClient,
+		rollupCfg:                    config.RollupCfg,
+		l2BlockRefsCache:             caching.NewLRUCache[common.Hash, eth.L2BlockRef](metrics, "blockrefs", config.L2BlockRefsCacheSize),
+		systemConfigsCache:           caching.NewLRUCache[common.Hash, eth.SystemConfig](metrics, "systemconfigs", config.L1ConfigsCacheSize),
+		fetchWithdrawalRootFromState: config.FetchWithdrawalRootFromState,
 	}, nil
 }
 
@@ -197,11 +201,14 @@ func (s *L2Client) outputV0(ctx context.Context, block eth.BlockInfo) (*eth.Outp
 
 	blockHash := block.Hash()
 	var messagePasserStorageRoot eth.Bytes32
-	if s.rollupCfg.IsIsthmus(block.Time()) {
-		// If Isthmus hard fork has activated, we can get the messagePasserStorageRoot directly from the header
+	if s.rollupCfg.IsIsthmus(block.Time()) && !s.fetchWithdrawalRootFromState {
+		s.log.Debug("Retrieving withdrawal root from block header")
+		// If Isthmus hard fork has activated, we can get the withdrawal root directly from the header
 		// instead of having to compute it from the contract storage trie.
 		messagePasserStorageRoot = eth.Bytes32(*block.WithdrawalsRoot())
+
 	} else {
+		s.log.Debug("Bypassing block header, retrieving withdrawal root from state")
 		proof, err := s.GetProof(ctx, predeploys.L2ToL1MessagePasserAddr, []common.Hash{}, blockHash.String())
 		if err != nil {
 			return nil, fmt.Errorf("failed to get contract proof at block %s: %w", blockHash, err)