op-node: rename EspressoEnforcementTime to EspressoTime

Matches upstream Optimism hardfork naming convention (RegolithTime,
EcotoneTime, IsthmusTime, ...). All hardforks enforce a new set of
rules, so the "Enforcement" qualifier was redundant.

Renames:
  EspressoEnforcementTime    -> EspressoTime    (rollup.Config field)
  IsEspressoEnforcement      -> IsEspresso      (rollup.Config method)
  espressoEnforcementTime    -> espressoTime    (DataSourceConfig field)
  isEspressoEnforcement      -> isEspresso      (DataSourceConfig method)
  espresso_enforcement_time  -> espresso_time   (JSON tag, forEachFork log key)
  "Espresso Enforcement"     -> "Espresso"      (forEachFork display name)

Also rewords prose docstrings: "EspressoEnforcement" -> "Espresso",
"Pre/Post-EspressoEnforcement" -> "Pre/Post-Espresso".

Addresses PR feedback: celo-org#445 (comment)

Co-authored-by: OpenCode <noreply@opencode.ai>

Author: QuentinI

op-node/rollup/derive/blob_data_source.go

@@ -119,21 +119,20 @@ func (ds *BlobDataSource) open(ctx context.Context) ([]blobOrCalldata, error) {
 // creates a placeholder blobOrCalldata element for each returned blob hash that must be populated
 // by fillBlobPointers after blob bodies are retrieved.
 //
-// Pre-EspressoEnforcement (the L1 origin time of `ref` is < *EspressoEnforcementTime,
-// or unset), this runs upstream Optimism semantics: filter by batch inbox + sender ==
+// Pre-Espresso (the L1 origin time of `ref` is < *EspressoTime, or unset),
+// this runs upstream Optimism semantics: filter by batch inbox + sender ==
 // batcher.
 //
-// Post-EspressoEnforcement, it collects all authenticated batch hashes from a
-// lookback window once and rejects any batch whose commitment hash is not in the
-// authenticated set. For blob transactions, the batch hash is computed from the
-// concatenated blob versioned hashes.
+// Post-Espresso, it collects all authenticated batch hashes from a lookback
+// window once and rejects any batch whose commitment hash is not in the
+// authenticated set. For blob transactions, the batch hash is computed from
+// the concatenated blob versioned hashes.
 func dataAndHashesFromTxs(ctx context.Context, txs types.Transactions, config *DataSourceConfig, batcherAddr common.Address, fetcher L1Fetcher, ref eth.L1BlockRef, logger log.Logger) ([]blobOrCalldata, []common.Hash, error) {
-	// Only collect authenticated batch hashes when the Espresso enforcement fork
-	// is active at the L1 origin time of the block we're scanning. Pre-fork, the
-	// upstream sender-based authorization path is used and authenticatedHashes is
-	// unused.
+	// Only collect authenticated batch hashes when the Espresso fork is active
+	// at the L1 origin time of the block we're scanning. Pre-fork, the upstream
+	// sender-based authorization path is used and authenticatedHashes is unused.
 	var authenticatedHashes map[common.Hash]bool
-	if config.isEspressoEnforcement(ref.Time) {
+	if config.isEspresso(ref.Time) {
 		var err error
 		authenticatedHashes, err = CollectAuthenticatedBatches(
 			ctx, fetcher, ref, config.batchAuthenticatorAddress, config.batchAuthLookbackWindow, logger,

op-node/rollup/derive/blob_data_source_test.go

@@ -123,9 +123,9 @@ func TestDataAndHashesFromTxs(t *testing.T) {
 // TestDataAndHashesFromTxsEventAuth tests event-based batch authentication for both
 // calldata and blob transactions in the blob data source path.
 //
-// Event-based authentication is only active post-EspressoEnforcement; the fixture
+// Event-based authentication is only active post-Espresso; the fixture
 // activates the fork at L1 origin time 0 (genesis) so all test refs satisfy
-// ref.Time >= *EspressoEnforcementTime.
+// ref.Time >= *EspressoTime.
 func TestDataAndHashesFromTxsEventAuth(t *testing.T) {
 	rng := rand.New(rand.NewSource(9999))
 	privateKey := testutils.InsecureRandomKey(rng)
@@ -137,13 +137,13 @@ func TestDataAndHashesFromTxsEventAuth(t *testing.T) {
 
 	chainId := new(big.Int).SetUint64(rng.Uint64())
 	signer := types.NewPragueSigner(chainId)
-	enforcementTime := uint64(0)
+	espressoTime := uint64(0)
 	config := DataSourceConfig{
 		l1Signer:                  signer,
 		batchInboxAddress:         batchInboxAddr,
 		batchAuthenticatorAddress: authenticatorAddr,
 		batchAuthLookbackWindow:   espresso.DefaultBatchAuthLookbackWindow,
-		espressoEnforcementTime:   &enforcementTime,
+		espressoTime:              &espressoTime,
 	}
 
 	ctx := context.Background()

op-node/rollup/derive/calldata_source.go

@@ -86,20 +86,20 @@ func (ds *CalldataSource) Next(ctx context.Context) (eth.Data, error) {
 // that are sent to the batch inbox address from the batch sender address.
 // This will return an empty array if no valid transactions are found.
 //
-// Pre-EspressoEnforcement (the L1 origin time of `ref` is < *EspressoEnforcementTime,
-// or unset), this runs upstream Optimism semantics: filter by batch inbox + sender ==
+// Pre-Espresso (the L1 origin time of `ref` is < *EspressoTime, or unset),
+// this runs upstream Optimism semantics: filter by batch inbox + sender ==
 // batcher.
 //
-// Post-EspressoEnforcement, it collects all authenticated batch hashes from a
-// lookback window once and rejects any batch whose commitment hash is not in the
+// Post-Espresso, it collects all authenticated batch hashes from a lookback
+// window once and rejects any batch whose commitment hash is not in the
 // authenticated set.
 func DataFromEVMTransactions(ctx context.Context, dsCfg DataSourceConfig, batcherAddr common.Address, txs types.Transactions, fetcher L1Fetcher, ref eth.L1BlockRef, log log.Logger) ([]eth.Data, error) {
-	// Only collect authenticated batch hashes when the Espresso enforcement fork
-	// is active at the L1 origin time of the block we're scanning. Pre-fork, the
-	// upstream sender-based authorization path inside isBatchTxAuthorized is used
-	// and the authenticatedHashes map is unused.
+	// Only collect authenticated batch hashes when the Espresso fork is active
+	// at the L1 origin time of the block we're scanning. Pre-fork, the upstream
+	// sender-based authorization path inside isBatchTxAuthorized is used and
+	// the authenticatedHashes map is unused.
 	var authenticatedHashes map[common.Hash]bool
-	if dsCfg.isEspressoEnforcement(ref.Time) {
+	if dsCfg.isEspresso(ref.Time) {
 		var err error
 		authenticatedHashes, err = CollectAuthenticatedBatches(
 			ctx, fetcher, ref, dsCfg.batchAuthenticatorAddress, dsCfg.batchAuthLookbackWindow, log,

op-node/rollup/derive/calldata_source_test.go

@@ -125,9 +125,9 @@ func mockAuthEvents(l1F *testutils.MockL1Source, rng *rand.Rand, ref eth.L1Block
 // TestDataFromEVMTransactionsEventAuth tests event-based batch authentication
 // where a BatchInfoAuthenticated event in the lookback window authorizes a batch.
 //
-// Event-based authentication is only active post-EspressoEnforcement; the fixture
+// Event-based authentication is only active post-Espresso; the fixture
 // activates the fork at L1 origin time 0 (genesis) so all test refs satisfy
-// ref.Time >= *EspressoEnforcementTime.
+// ref.Time >= *EspressoTime.
 func TestDataFromEVMTransactionsEventAuth(t *testing.T) {
 	rng := rand.New(rand.NewSource(42))
 	batcherPriv := testutils.RandomKey()
@@ -137,13 +137,13 @@ func TestDataFromEVMTransactionsEventAuth(t *testing.T) {
 	batcherAddr := crypto.PubkeyToAddress(batcherPriv.PublicKey)
 	signer := types.NewCancunSigner(big.NewInt(100))
 
-	enforcementTime := uint64(0)
+	espressoTime := uint64(0)
 	dsCfg := DataSourceConfig{
 		l1Signer:                  signer,
 		batchInboxAddress:         batchInboxAddr,
 		batchAuthenticatorAddress: authenticatorAddr,
 		batchAuthLookbackWindow:   espresso.DefaultBatchAuthLookbackWindow,
-		espressoEnforcementTime:   &enforcementTime,
+		espressoTime:              &espressoTime,
 	}
 
 	ctx := context.Background()
@@ -374,7 +374,7 @@ func TestDataFromEVMTransactions(t *testing.T) {
 			}
 		}
 
-		// Legacy mode (no batch authenticator, EspressoEnforcement inactive) — uses sender-based auth
+		// Legacy mode (no batch authenticator, Espresso inactive) — uses sender-based auth
 		dsCfg := DataSourceConfig{
 			l1Signer:          cfg.L1Signer(),
 			batchInboxAddress: cfg.BatchInboxAddress,

op-node/rollup/derive/data_source.go

@@ -54,7 +54,7 @@ func NewDataSourceFactory(log log.Logger, cfg *rollup.Config, fetcher L1Fetcher,
 		altDAEnabled:              cfg.AltDAEnabled(),
 		batchAuthenticatorAddress: cfg.BatchAuthenticatorAddress,
 		batchAuthLookbackWindow:   cfg.BatchAuthLookbackWindowOrDefault(),
-		espressoEnforcementTime:   cfg.EspressoEnforcementTime,
+		espressoTime:              cfg.EspressoTime,
 	}
 	return &DataSourceFactory{
 		log:          log,
@@ -68,12 +68,12 @@ func NewDataSourceFactory(log log.Logger, cfg *rollup.Config, fetcher L1Fetcher,
 
 // OpenData returns the appropriate data source for the L1 block `ref`.
 //
-// The Espresso enforcement gate is evaluated against the L1 origin time
-// (ref.Time), mirroring the upstream pattern used for ecotoneTime: the
-// data-source layer is per-L1-block, so it gates on L1 time. The fork timestamp
-// itself is conceptually an L2 timestamp but the per-L1-block decision is
-// stable as long as L1 origin time and L2 block time are within
-// MaxSequencerDrift of each other (always true on a healthy chain).
+// The Espresso gate is evaluated against the L1 origin time (ref.Time),
+// mirroring the upstream pattern used for ecotoneTime: the data-source layer
+// is per-L1-block, so it gates on L1 time. The fork timestamp itself is
+// conceptually an L2 timestamp but the per-L1-block decision is stable as
+// long as L1 origin time and L2 block time are within MaxSequencerDrift of
+// each other (always true on a healthy chain).
 func (ds *DataSourceFactory) OpenData(ctx context.Context, ref eth.L1BlockRef, batcherAddr common.Address) (DataIter, error) {
 	// Creates a data iterator from blob or calldata source so we can forward it to the altDA source
 	// if enabled as it still requires an L1 data source for fetching input commmitments.
@@ -99,25 +99,25 @@ type DataSourceConfig struct {
 	batchInboxAddress common.Address
 	altDAEnabled      bool
 	// batchAuthenticatorAddress is the L1 address of the BatchAuthenticator contract.
-	// Event-based authentication via this contract is required only post-EspressoEnforcement
+	// Event-based authentication via this contract is required only post-Espresso
 	// activation; pre-fork the data source uses upstream sender-based authorization.
 	batchAuthenticatorAddress common.Address
 	// batchAuthLookbackWindow is the number of L1 blocks to scan for BatchInfoAuthenticated events.
 	batchAuthLookbackWindow uint64
-	// espressoEnforcementTime is the activation timestamp of the Espresso enforcement
-	// hardfork. When the L1 origin time of the block being scanned is >=
-	// *espressoEnforcementTime (and this pointer is non-nil), batches must be
-	// authenticated by emitted BatchInfoAuthenticated events. Otherwise upstream
-	// sender-based authorization applies.
-	espressoEnforcementTime *uint64
+	// espressoTime is the activation timestamp of the Espresso hardfork. When the
+	// L1 origin time of the block being scanned is >= *espressoTime (and this
+	// pointer is non-nil), batches must be authenticated by emitted
+	// BatchInfoAuthenticated events. Otherwise upstream sender-based
+	// authorization applies.
+	espressoTime *uint64
 }
 
-// isEspressoEnforcement returns true if Espresso enforcement is active for the
-// given L1 origin time. The fork is conceptually an L2-timestamp hardfork but
-// the per-L1-block data-source decision is gated on L1 origin time, mirroring
+// isEspresso returns true if the Espresso hardfork is active for the given L1
+// origin time. The fork is conceptually an L2-timestamp hardfork but the
+// per-L1-block data-source decision is gated on L1 origin time, mirroring
 // upstream's ecotoneTime treatment.
-func (c DataSourceConfig) isEspressoEnforcement(l1OriginTime uint64) bool {
-	return c.espressoEnforcementTime != nil && l1OriginTime >= *c.espressoEnforcementTime
+func (c DataSourceConfig) isEspresso(l1OriginTime uint64) bool {
+	return c.espressoTime != nil && l1OriginTime >= *c.espressoTime
 }
 
 // isValidBatchTx checks basic transaction validity for batch submission:
@@ -142,7 +142,7 @@ func isValidBatchTx(tx *types.Transaction, batchInboxAddr common.Address, logger
 
 // isAuthorizedBatchSender performs upstream-style sender-based authorization: it
 // recovers the L1 sender of the transaction and checks it matches the configured
-// batcher address. This is the pre-EspressoEnforcement authorization path.
+// batcher address. This is the pre-Espresso authorization path.
 func isAuthorizedBatchSender(tx *types.Transaction, l1Signer types.Signer, batcherAddr common.Address, logger log.Logger) bool {
 	sender, err := l1Signer.Sender(tx)
 	if err != nil {
@@ -162,12 +162,12 @@ func isAuthorizedBatchSender(tx *types.Transaction, l1Signer types.Signer, batch
 // block (passed as l1OriginTime), mirroring the data-source layer's ecotoneTime
 // treatment.
 //
-// Pre-EspressoEnforcement (l1OriginTime < *EspressoEnforcementTime, or unset):
+// Pre-Espresso (l1OriginTime < *EspressoTime, or unset):
 //
 //	upstream behavior — the L1 sender of the transaction must match the configured
 //	batcher address. The authenticatedHashes map is unused.
 //
-// Post-EspressoEnforcement:
+// Post-Espresso:
 //
 //	the batch's commitment hash must appear in authenticatedHashes (i.e. a
 //	BatchInfoAuthenticated event was emitted for this commitment within the
@@ -181,7 +181,7 @@ func isBatchTxAuthorized(
 	l1OriginTime uint64,
 	logger log.Logger,
 ) bool {
-	if !dsCfg.isEspressoEnforcement(l1OriginTime) {
+	if !dsCfg.isEspresso(l1OriginTime) {
 		// Pre-fork: upstream sender-based authorization.
 		return isAuthorizedBatchSender(tx, dsCfg.l1Signer, batcherAddr, logger)
 	}

op-node/rollup/espresso_types.go

@@ -1,10 +1,10 @@
 package rollup
 
-// IsEspressoEnforcement returns true if the Espresso enforcement upgrade is
-// active at or past the given L2 block timestamp. When active, the derivation
-// pipeline runs all Espresso-specific semantics (event-based batch
-// authentication via the BatchAuthenticator contract). When inactive, the
-// pipeline behaves exactly as upstream Optimism.
-func (c *Config) IsEspressoEnforcement(timestamp uint64) bool {
-	return c.EspressoEnforcementTime != nil && timestamp >= *c.EspressoEnforcementTime
+// IsEspresso returns true if the Espresso upgrade is active at or past the
+// given L2 block timestamp. When active, the derivation pipeline runs all
+// Espresso-specific semantics (event-based batch authentication via the
+// BatchAuthenticator contract). When inactive, the pipeline behaves exactly
+// as upstream Optimism.
+func (c *Config) IsEspresso(timestamp uint64) bool {
+	return c.EspressoTime != nil && timestamp >= *c.EspressoTime
 }

op-node/rollup/types.go

@@ -170,16 +170,16 @@ type Config struct {
 	// epoch.
 	PectraBlobScheduleTime *uint64 `json:"pectra_blob_schedule_time,omitempty"`
 
-	// EspressoEnforcementTime sets the activation time of the Espresso enforcement upgrade.
+	// EspressoTime sets the activation time of the Espresso upgrade.
 	// Pre-fork, the derivation pipeline behaves exactly as upstream Optimism: batches are
 	// accepted based on the L1 transaction sender matching the SystemConfig batcher address.
 	// Post-fork, batches must be authenticated via BatchInfoAuthenticated events emitted by
 	// the BatchAuthenticator contract; sender-based authorization is rejected.
-	// Active if EspressoEnforcementTime != nil && L2 block timestamp >= *EspressoEnforcementTime.
-	EspressoEnforcementTime *uint64 `json:"espresso_enforcement_time,omitempty"`
+	// Active if EspressoTime != nil && L2 block timestamp >= *EspressoTime.
+	EspressoTime *uint64 `json:"espresso_time,omitempty"`
 
 	// BatchAuthenticatorAddress is the L1 address of the BatchAuthenticator contract whose
-	// BatchInfoAuthenticated(bytes32) events the derivation pipeline scans post-EspressoEnforcement.
+	// BatchInfoAuthenticated(bytes32) events the derivation pipeline scans post-Espresso.
 	BatchAuthenticatorAddress common.Address `json:"batch_authenticator_address,omitempty,omitzero"`
 
 	// BatchAuthLookbackWindow is the number of L1 blocks to scan for BatchInfoAuthenticated events.
@@ -890,9 +890,9 @@ func (c *Config) forEachFork(callback func(name string, logName string, time *ui
 	callback("Jovian", "jovian_time", c.JovianTime)
 	callback("Karst", "karst_time", c.KarstTime)
 	callback("Interop", "interop_time", c.InteropTime)
-	if c.EspressoEnforcementTime != nil {
+	if c.EspressoTime != nil {
 		// only report if config is set
-		callback("Espresso Enforcement", "espresso_enforcement_time", c.EspressoEnforcementTime)
+		callback("Espresso", "espresso_time", c.EspressoTime)
 	}
 }