Use correct L1 client for verifying origin in streamer

Author: QuentinI

espresso/cli.go

@@ -35,6 +35,7 @@ var (
 	TestingBatcherPrivateKeyFlagName = espressoFlags("testing-batcher-private-key")
 	OriginHeight                     = espressoFlags("origin-height")
 	NamespaceFlagName                = espressoFlags("namespace")
+	RollupL1UrlFlagName              = espressoFlags("rollup-l1-url")
 )
 
 func CLIFlags(envPrefix string, category string) []cli.Flag {
@@ -96,6 +97,12 @@ func CLIFlags(envPrefix string, category string) []cli.Flag {
 			EnvVars:  espressoEnvs(envPrefix, "NAMESPACE"),
 			Category: category,
 		},
+		&cli.StringFlag{
+			Name:     RollupL1UrlFlagName,
+			Usage:    "RPC URL of L1 backing the Rollup we're streaming for",
+			EnvVars:  espressoEnvs(envPrefix, "ROLLUP_L1_URL"),
+			Category: category,
+		},
 	}
 }
 
@@ -106,6 +113,7 @@ type CLIConfig struct {
 	QueryServiceURLs         []string
 	LightClientAddr          common.Address
 	L1URL                    string
+	RollupL1URL              string
 	TestingBatcherPrivateKey *ecdsa.PrivateKey
 	Namespace                uint64
 	OriginHeight             uint64
@@ -123,6 +131,9 @@ func (c CLIConfig) Check() error {
 		if c.L1URL == "" {
 			return fmt.Errorf("L1 URL is required when Espresso is enabled")
 		}
+		if c.RollupL1URL == "" {
+			return fmt.Errorf("rollup L1 URL is required when Espresso is enabled")
+		}
 		if c.Namespace == 0 {
 			return fmt.Errorf("namespace is required when Espresso is enabled")
 		}
@@ -136,6 +147,7 @@ func ReadCLIConfig(c *cli.Context) CLIConfig {
 		PollInterval: c.Duration(PollIntervalFlagName),
 		UseFetchAPI:  c.Bool(UseFetchApiFlagName),
 		L1URL:        c.String(L1UrlFlagName),
+		RollupL1URL:  c.String(RollupL1UrlFlagName),
 		Namespace:    c.Uint64(NamespaceFlagName),
 		OriginHeight: c.Uint64(OriginHeight),
 	}
@@ -169,6 +181,11 @@ func BatchStreamerFromCLIConfig[B Batch](
 		return nil, fmt.Errorf("failed to dial L1 RPC: %w", err)
 	}
 
+	RollupL1Client, err := ethclient.Dial(cfg.RollupL1URL)
+	if err != nil {
+		return nil, fmt.Errorf("failed to dial Rollup L1 RPC: %w", err)
+	}
+
 	espressoClient, err := espressoClient.NewMultipleNodesClient(cfg.QueryServiceURLs)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create Espresso client: %w", err)
@@ -182,6 +199,7 @@ func BatchStreamerFromCLIConfig[B Batch](
 	streamer := NewEspressoStreamer(
 		cfg.Namespace,
 		NewAdaptL1BlockRefClient(l1Client),
+		NewAdaptL1BlockRefClient(RollupL1Client),
 		espressoClient,
 		espressoLightClient,
 		log,

espresso/environment/2_espresso_liveness_test.go

@@ -262,6 +262,7 @@ func TestE2eDevnetWithEspressoDegradedLivenessViaCaffNode(t *testing.T) {
 		streamer := espresso.NewEspressoStreamer(
 			system.RollupConfig.L2ChainID.Uint64(),
 			espresso.NewAdaptL1BlockRefClient(l1Client),
+			espresso.NewAdaptL1BlockRefClient(l1Client),
 			espressoClient.NewClient(server.URL),
 			lightClient,
 			l,

espresso/environment/enclave_helpers.go

@@ -96,6 +96,7 @@ func LaunchBatcherInEnclave() E2eDevnetLauncherOption {
 						appendArg(&args, flags.L1EthRpcFlag.Name, l1Rpc)
 						appendArg(&args, txmgr.L1RPCFlagName, l1Rpc)
 						appendArg(&args, espresso.L1UrlFlagName, l1Rpc)
+						appendArg(&args, espresso.RollupL1UrlFlagName, l1Rpc)
 						l2EthRpc := sys.EthInstances[e2esys.RoleSeq].UserRPC().(endpoint.HttpRPC).HttpRPC()
 						appendArg(&args, flags.L2EthRpcFlag.Name, l2EthRpc)
 						rollupRpc := sys.RollupNodes[e2esys.RoleSeq].UserRPC().(endpoint.HttpRPC).HttpRPC()

espresso/environment/espresso_caff_node.go

@@ -118,6 +118,7 @@ func LaunchCaffNode(t *testing.T, system *e2esys.System, espressoDevNode Espress
 		// To create a valid multiple nodes client, we need to provide at least 2 URLs.
 		QueryServiceURLs: []string{u.String(), u.String()},
 		L1URL:            system.L1.UserRPC().RPC(),
+		RollupL1URL:      system.L1.UserRPC().RPC(),
 		LightClientAddr:  common.HexToAddress(ESPRESSO_LIGHT_CLIENT_ADDRESS),
 	}
 

espresso/streamer.go

@@ -74,6 +74,7 @@ type BatchStreamer[B Batch] struct {
 	Namespace uint64
 
 	L1Client                      L1Client
+	RollupL1Client                L1Client
 	EspressoClient                EspressoClient
 	EspressoLightClient           LightClientCallerInterface
 	Log                           log.Logger
@@ -112,6 +113,7 @@ var _ EspressoStreamer[Batch] = (*BatchStreamer[Batch])(nil)
 func NewEspressoStreamer[B Batch](
 	namespace uint64,
 	l1Client L1Client,
+	rollupL1Client L1Client,
 	espressoClient EspressoClient,
 	lightClient LightClientCallerInterface,
 	log log.Logger,
@@ -121,6 +123,7 @@ func NewEspressoStreamer[B Batch](
 ) *BatchStreamer[B] {
 	return &BatchStreamer[B]{
 		L1Client:                      l1Client,
+		RollupL1Client:                rollupL1Client,
 		EspressoClient:                espressoClient,
 		EspressoLightClient:           lightClient,
 		Log:                           log,
@@ -193,7 +196,7 @@ func (s *BatchStreamer[B]) CheckBatch(ctx context.Context, batch B) (BatchValidi
 		return BatchUndecided, 0
 	}
 
-	l1headerHash, err := s.L1Client.HeaderHashByNumber(ctx, new(big.Int).SetUint64(origin.Number))
+	l1headerHash, err := s.RollupL1Client.HeaderHashByNumber(ctx, new(big.Int).SetUint64(origin.Number))
 	if err != nil {
 		// Signal to resync to be able to fetch the L1 header.
 		s.Log.Warn("Failed to fetch the L1 header, pending resync", "error", err)

espresso/streamer_test.go

@@ -35,6 +35,7 @@ func TestNewEspressoStreamer(t *testing.T) {
 	_ = espresso.NewEspressoStreamer(
 		1,
 		nil,
+		nil,
 		nil, nil, nil, derive.CreateEspressoBatchUnmarshaler(common.Address{}),
 		50*time.Millisecond,
 		0,
@@ -356,6 +357,7 @@ func setupStreamerTesting(namespace uint64, batcherAddress common.Address) (*Moc
 		state,
 		state,
 		state,
+		state,
 		logger,
 		derive.CreateEspressoBatchUnmarshaler(batcherAddress),
 		50*time.Millisecond,

op-batcher/batcher/service.go

@@ -541,6 +541,14 @@ func (bs *BatcherService) initEspresso(cfg *CLIConfig) error {
 		return nil
 	}
 
+	if cfg.Espresso.RollupL1URL == "" {
+		cfg.Espresso.RollupL1URL = cfg.L1EthRpc
+	}
+
+	if cfg.Espresso.RollupL1URL != cfg.L1EthRpc {
+		log.Warn("Espresso Rollup L1 URL differs from batcher's L1EthRpc")
+	}
+
 	if cfg.Espresso.L1URL == "" {
 		log.Warn("Espresso L1 URL not provided, using batcher's L1EthRpc")
 		cfg.Espresso.L1URL = cfg.L1EthRpc

op-batcher/enclave-entrypoint.bash

@@ -6,7 +6,7 @@
 # to directly pass commandline arguments when starting EIF images)
 
 # We will need to start a proxy for each of those urls
-URL_ARG_RE='^(--altda\.da-server|--espresso\.urls|--espresso.\l1-url|--l1-eth-rpc|--l2-eth-rpc|--rollup-rpc|--signer\.endpoint)(=|$)'
+URL_ARG_RE='^(--altda\.da-server|--espresso\.urls|--espresso.\l1-url|--espresso.rollup-l1-url|--l1-eth-rpc|--l2-eth-rpc|--rollup-rpc|--signer\.endpoint)(=|$)'
 
 # Re-populate the arguments passed through the environment
 if [ -n "$ENCLAVE_BATCHER_ARGS" ]; then

op-e2e/system/e2esys/setup.go

@@ -1024,6 +1024,7 @@ func (cfg SystemConfig) Start(t *testing.T, startOpts ...StartOption) (*System,
 		Enabled:                  (cfg.AllocType == config.AllocTypeEspressoWithEnclave) || (cfg.AllocType == config.AllocTypeEspressoWithoutEnclave),
 		PollInterval:             250 * time.Millisecond,
 		L1URL:                    sys.EthInstances[RoleL1].UserRPC().RPC(),
+		RollupL1URL:              sys.EthInstances[RoleL1].UserRPC().RPC(),
 		TestingBatcherPrivateKey: testingBatcherPk,
 	}
 

op-node/service.go

@@ -69,6 +69,14 @@ func NewConfig(ctx *cli.Context, log log.Logger) (*config.Config, error) {
 
 	l1Endpoint := NewL1EndpointConfig(ctx)
 
+	if rollupConfig.CaffNodeConfig.RollupL1URL == "" {
+		rollupConfig.CaffNodeConfig.RollupL1URL = l1Endpoint.L1NodeAddr
+	}
+
+	if l1Endpoint.L1NodeAddr != rollupConfig.CaffNodeConfig.RollupL1URL {
+		log.Warn("Espresso streamer rollup L1 URL does not match L1 node address of caff node", "rollupL1URL", rollupConfig.CaffNodeConfig.RollupL1URL, "l1NodeAddr", l1Endpoint.L1NodeAddr)
+	}
+
 	l2Endpoint, err := NewL2EndpointConfig(ctx, log)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load l2 endpoints info: %w", err)