feat(chainspec): activate Unzen from genesis + drop special zk-gas schedule for Masaya (#205)

* feat(chainspec): reset Masaya to activate Unzen at genesis

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* refactor(evm): drop Masaya-specific zk-gas schedule

Masaya is being reset to fork into Unzen from genesis, so the frozen
pre-recalibration schedule that preserved consensus on its old finalized
blocks is no longer needed. Collapse every chain onto UNZEN_ZK_GAS_SCHEDULE
and drop the now-unused chain_id parameter from schedule_for.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: davidtaikocha

crates/block/src/executor.rs

@@ -397,8 +397,8 @@ where
         // Charge the per-transaction intrinsic zk gas before EVM execution begins, as required
         // by the Unzen zk gas spec (taikoxyz/taiko-mono#21669). The intrinsic sits in the
         // in-flight tx total so it is committed alongside opcode/precompile usage on success
-        // and discarded on revert/failure. A schedule with a zero intrinsic (Masaya) makes this
-        // a no-op. If the intrinsic alone would exceed the remaining block budget, mirror the
+        // and discarded on revert/failure. A schedule with a zero intrinsic makes this a no-op.
+        // If the intrinsic alone would exceed the remaining block budget, mirror the
         // mid-tx exhaustion path used by the inspector.
         if let Err(ZkGasOutcome::LimitExceeded) = self.evm.charge_tx_intrinsic_zk_gas() {
             self.zk_gas_exhausted = true;
@@ -558,19 +558,17 @@ mod test {
         state::AccountInfo,
     };
 
-    use alethia_reth_chainspec::TAIKO_MASAYA_CHAIN_ID;
     use alethia_reth_evm::{
-        alloy::decode_anchor_system_call_data,
-        factory::TaikoEvmFactory,
-        zk_gas::unzen::{MASAYA_TX_INTRINSIC_ZK_GAS, TX_INTRINSIC_ZK_GAS},
+        alloy::decode_anchor_system_call_data, factory::TaikoEvmFactory,
+        zk_gas::unzen::TX_INTRINSIC_ZK_GAS,
     };
 
     use super::*;
     use crate::{
         config::{TaikoEvmConfig, TaikoNextBlockEnvAttributes},
         testutil::{
             BENCH_LIMIT_TARGET, BENCH_SUCCESS_TARGET, db_with_contracts, recovered_tx,
-            recovered_tx_with_chain_id, unzen_chain_spec, unzen_evm_env, unzen_execution_ctx,
+            unzen_chain_spec, unzen_evm_env, unzen_execution_ctx,
         },
     };
     use alethia_reth_chainspec::spec::TaikoChainSpec;
@@ -665,39 +663,6 @@ mod test {
         );
     }
 
-    #[test]
-    fn executor_does_not_charge_tx_intrinsic_on_masaya_schedule() {
-        let chain_spec = Arc::new(unzen_chain_spec());
-        let mut state = State::builder()
-            .with_database(db_with_contracts(&[(BENCH_CALLER, 0)]))
-            .with_bundle_update()
-            .build();
-        let mut env = unzen_evm_env();
-        env.cfg_env.chain_id = TAIKO_MASAYA_CHAIN_ID;
-        let evm = TaikoEvmFactory.create_evm(&mut state, env);
-        let ctx = unzen_execution_ctx();
-        let mut executor =
-            TaikoBlockExecutor::new(evm, ctx.clone(), chain_spec, RethReceiptBuilder::default());
-
-        executor
-            .execute_transaction(recovered_tx_with_chain_id(
-                BENCH_CALLER,
-                BENCH_SUCCESS_TARGET,
-                0,
-                1,
-                TAIKO_MASAYA_CHAIN_ID,
-            ))
-            .expect("successful tx should commit on Masaya");
-
-        let finalized = ctx.finalized_block_zk_gas();
-        assert_eq!(MASAYA_TX_INTRINSIC_ZK_GAS, 0);
-        assert!(
-            finalized < TX_INTRINSIC_ZK_GAS,
-            "Masaya finalized block zk gas ({finalized}) must not include any per-tx intrinsic charge"
-        );
-        assert!(finalized > 0, "successful tx must still record opcode-driven zk gas (got 0)");
-    }
-
     #[cfg(feature = "prover")]
     #[test]
     fn execute_block_stops_after_non_anchor_zk_gas_exhaustion() {

crates/block/src/testutil.rs

@@ -75,7 +75,7 @@ pub fn recovered_tx(
 }
 
 /// Builds a recovered legacy transaction targeting `to` from `caller` with an explicit chain id,
-/// so tests can submit transactions against the Masaya chain id (`167_011`) and others.
+/// so tests can submit transactions against chain ids other than the default.
 pub fn recovered_tx_with_chain_id(
     caller: Address,
     to: Address,

crates/chainspec/src/hardfork.rs

@@ -102,7 +102,7 @@ pub static TAIKO_MASAYA_HARDFORKS: LazyLock<ChainHardforks> = LazyLock::new(|| {
         (TaikoHardfork::Ontake.boxed(), ForkCondition::Block(0)),
         (TaikoHardfork::Pacaya.boxed(), ForkCondition::Block(0)),
         (TaikoHardfork::Shasta.boxed(), ForkCondition::Timestamp(0)),
-        (TaikoHardfork::Unzen.boxed(), ForkCondition::Timestamp(1_778_158_800)),
+        (TaikoHardfork::Unzen.boxed(), ForkCondition::Timestamp(0)),
     ]))
 });
 
@@ -224,4 +224,14 @@ mod test {
         assert!(shasta.is_timestamp(), "shasta activation should be timestamp-based");
         assert_eq!(shasta, ForkCondition::Timestamp(0));
     }
+
+    #[test]
+    fn test_masaya_unzen_activates_at_genesis() {
+        let unzen = TAIKO_MASAYA_HARDFORKS.fork(TaikoHardfork::Unzen);
+        assert_eq!(
+            unzen,
+            ForkCondition::Timestamp(0),
+            "post-reset Masaya forks into Unzen at genesis"
+        );
+    }
 }

crates/chainspec/src/lib.rs

@@ -39,9 +39,10 @@ pub const TAIKO_HOODI_GENESIS_HASH: B256 =
 pub const TAIKO_MAINNET_GENESIS_HASH: B256 =
     b256!("0x90bc60466882de9637e269e87abab53c9108cf9113188bc4f80bcfcb10e489b9");
 
-/// Genesis hash for the Taiko Masaya network.
+/// Genesis hash for the Taiko Masaya network. After the reset, Masaya activates Unzen at genesis
+/// (`Timestamp(0)`), which makes the genesis header an Osaka-era block.
 pub const TAIKO_MASAYA_GENESIS_HASH: B256 =
-    b256!("0xeef96dc254e1ac4a0044b116e38b16dface1a153d9299c056552898a43f8513e");
+    b256!("0xd3597fd63c823352526ce2a4cfafe0837d878e3c9ac8558129bc04ce900402ae");
 
 /// EVM chain id for the Taiko Devnet network.
 pub const TAIKO_DEVNET_CHAIN_ID: u64 = 167_001;

crates/evm/src/factory.rs

@@ -48,7 +48,7 @@ impl EvmFactory for TaikoEvmFactory {
         input: EvmEnv<Self::Spec, Self::BlockEnv>,
     ) -> Self::Evm<DB, NoOpInspector> {
         let spec_id = input.cfg_env.spec;
-        let schedule = schedule_for(spec_id, input.cfg_env.chain_id);
+        let schedule = schedule_for(spec_id);
         let evm = Context::mainnet()
             .with_cfg(input.cfg_env)
             .with_block(input.block_env)
@@ -69,7 +69,7 @@ impl EvmFactory for TaikoEvmFactory {
         inspector: I,
     ) -> Self::Evm<DB, I> {
         let spec_id = input.cfg_env.spec;
-        let schedule = schedule_for(spec_id, input.cfg_env.chain_id);
+        let schedule = schedule_for(spec_id);
         let evm = Context::mainnet()
             .with_cfg(input.cfg_env)
             .with_block(input.block_env)

crates/evm/src/zk_gas/adapter.rs

@@ -62,16 +62,14 @@ impl<I> ZkGasInspector<I> {
 
     /// Returns a reference to the active zk gas meter, if metering is enabled.
     ///
-    /// Returns `None` when the active spec/chain combination has no zk gas schedule
-    /// (pre-Unzen specs).
+    /// Returns `None` when the active spec has no zk gas schedule (pre-Unzen specs).
     pub(crate) fn meter(&self) -> Option<&ZkGasMeter<'static>> {
         self.metering.as_ref().map(|state| &state.meter)
     }
 
     /// Returns a mutable reference to the active zk gas meter, if metering is enabled.
     ///
-    /// Returns `None` when the active spec/chain combination has no zk gas schedule
-    /// (pre-Unzen specs).
+    /// Returns `None` when the active spec has no zk gas schedule (pre-Unzen specs).
     pub(crate) fn meter_mut(&mut self) -> Option<&mut ZkGasMeter<'static>> {
         self.metering.as_mut().map(|state| &mut state.meter)
     }
@@ -413,17 +411,14 @@ fn parent_step_depth(depth: usize) -> usize {
 mod tests {
     use crate::{
         spec::TaikoSpecId,
-        zk_gas::{
-            schedule::schedule_for,
-            unzen::{MASAYA_UNZEN_ZK_GAS_SCHEDULE, UNZEN_ZK_GAS_SCHEDULE},
-        },
+        zk_gas::{schedule::schedule_for, unzen::UNZEN_ZK_GAS_SCHEDULE},
     };
 
     use super::{FinishedStep, ZkGasMeteringState};
 
     #[test]
     fn flush_deferred_steps_returns_immediately_when_empty() {
-        let schedule = schedule_for(TaikoSpecId::UNZEN, 167).expect("Unzen schedule");
+        let schedule = schedule_for(TaikoSpecId::UNZEN).expect("Unzen schedule");
         let mut metering = ZkGasMeteringState::new(schedule);
 
         metering.flush_deferred_steps().expect("empty flush should succeed");
@@ -434,7 +429,7 @@ mod tests {
 
     #[test]
     fn flush_deferred_steps_clears_flag_after_charging_deferred_step() {
-        let schedule = schedule_for(TaikoSpecId::UNZEN, 167).expect("Unzen schedule");
+        let schedule = schedule_for(TaikoSpecId::UNZEN).expect("Unzen schedule");
         let mut metering = ZkGasMeteringState::new(schedule);
 
         metering.defer_step(0, FinishedStep { opcode: 0x01, step_gas: 3, spawned: false });
@@ -449,13 +444,13 @@ mod tests {
 
     #[test]
     fn flush_deferred_steps_preserves_flag_when_later_deferred_step_remains_after_error() {
-        let mut metering = ZkGasMeteringState::new(&MASAYA_UNZEN_ZK_GAS_SCHEDULE);
+        let mut metering = ZkGasMeteringState::new(&UNZEN_ZK_GAS_SCHEDULE);
 
         metering.defer_step(
             0,
             FinishedStep {
                 opcode: 0xf0,
-                step_gas: MASAYA_UNZEN_ZK_GAS_SCHEDULE.block_limit + 1,
+                step_gas: UNZEN_ZK_GAS_SCHEDULE.block_limit + 1,
                 spawned: false,
             },
         );

crates/evm/src/zk_gas/meter.rs

@@ -99,7 +99,7 @@ impl<'a> ZkGasMeter<'a> {
     ///
     /// Mirrors `TX_INTRINSIC_ZK_GAS` from the Unzen zk gas spec: the charge accumulates into the
     /// in-flight transaction total and is only promoted into the block total when the transaction
-    /// commits. A schedule value of `0` (Masaya) makes this a no-op.
+    /// commits. A schedule value of `0` makes this a no-op.
     pub fn charge_tx_intrinsic(&mut self) -> Result<(), ZkGasOutcome> {
         self.charge_amount(self.schedule.tx_intrinsic_zk_gas)
     }

crates/evm/src/zk_gas/schedule.rs

@@ -4,9 +4,7 @@ use alloy_primitives::Address;
 
 use crate::spec::TaikoSpecId;
 
-use super::unzen::{MASAYA_UNZEN_ZK_GAS_SCHEDULE, UNZEN_ZK_GAS_SCHEDULE};
-
-pub use alethia_reth_chainspec::TAIKO_MASAYA_CHAIN_ID;
+use super::unzen::UNZEN_ZK_GAS_SCHEDULE;
 
 /// Fail-safe multiplier applied to any precompile absent from a schedule's table.
 pub const FAILSAFE_MULTIPLIER: u16 = u16::MAX;
@@ -34,8 +32,7 @@ pub struct ZkGasSchedule {
     /// Maximum zk gas permitted across a single block.
     pub block_limit: u64,
     /// Fixed zk gas charged once per block transaction before opcode or precompile
-    /// metering begins. Set to `0` on chains whose Unzen activation predates this
-    /// field, to preserve historical block consensus.
+    /// metering begins.
     pub tx_intrinsic_zk_gas: u64,
     /// Per-opcode proving-cost multipliers indexed by opcode byte.
     pub opcode_multipliers: [u16; 256],
@@ -57,16 +54,11 @@ impl ZkGasSchedule {
     }
 }
 
-/// Returns the consensus zk gas schedule for the active Taiko fork on the given chain, when
-/// defined. Masaya runs Unzen with a 10× higher block budget than Devnet/Hoodi/Mainnet; all
-/// other chains share the default Unzen schedule.
-pub const fn schedule_for(spec: TaikoSpecId, chain_id: u64) -> Option<&'static ZkGasSchedule> {
+/// Returns the consensus zk gas schedule for the active Taiko fork, when defined. Only Unzen
+/// defines a schedule; every chain shares the single [`UNZEN_ZK_GAS_SCHEDULE`].
+pub const fn schedule_for(spec: TaikoSpecId) -> Option<&'static ZkGasSchedule> {
     match spec {
-        TaikoSpecId::UNZEN => Some(if chain_id == TAIKO_MASAYA_CHAIN_ID {
-            &MASAYA_UNZEN_ZK_GAS_SCHEDULE
-        } else {
-            &UNZEN_ZK_GAS_SCHEDULE
-        }),
+        TaikoSpecId::UNZEN => Some(&UNZEN_ZK_GAS_SCHEDULE),
         _ => None,
     }
 }