feat: support MorphTx v2 with EIP-7702 authorization lists

bin/morph-statetest/Cargo.toml

@@ -16,6 +16,7 @@ eyre.workspace = true
 morph-chainspec.workspace = true
 morph-evm.workspace = true
 morph-revm.workspace = true
+morph-primitives.workspace = true
 revm = { workspace = true, features = ["tracer"] }
 revm-statetest-types.workspace = true
 serde.workspace = true

bin/morph-statetest/src/schema.rs

@@ -1,4 +1,5 @@
 use morph_chainspec::hardfork::MorphHardfork;
+use morph_primitives::transaction::morph_transaction::MORPH_TX_VERSION_2;
 use morph_revm::{MorphTxEnv, MorphTxExt};
 use revm::{
     context::{BlockEnv, CfgEnv, TransactionType, TxEnv},
@@ -282,6 +283,12 @@ impl MorphTransactionParts {
         let mut tx = MorphTxEnv::new(inner);
         if let Some(version) = self.version {
             tx = tx.with_version(version);
+        } else if tx.is_morph_tx() && self.authorization_list.is_some() {
+            // Only V2 may carry an `authorizationList` field, so its presence
+            // (even `[]`) selects V2 instead of leaving the version unset, which
+            // the handler would treat as V0. Presence rather than length is the
+            // same convention `tx_type` uses to select 0x04.
+            tx = tx.with_version(MORPH_TX_VERSION_2);
         }
         if let Some(fee_token_id) = self.fee_token_id {
             tx = tx.with_fee_token_id(fee_token_id);
@@ -358,7 +365,10 @@ pub fn parse_fork(name: &str) -> Result<MorphHardfork, SchemaError> {
         "morph203" | "morph-203" => Ok(MorphHardfork::Morph203),
         "viridian" | "prague" => Ok(MorphHardfork::Viridian),
         "emerald" => Ok(MorphHardfork::Emerald),
-        "jade" | "osaka" => Ok(MorphHardfork::Jade),
+        "jade" => Ok(MorphHardfork::Jade),
+        // OSAKA is the spec level of the latest Morph fork, so the generic
+        // Ethereum name maps to it (matches `MorphHardfork::from(SpecId::OSAKA)`).
+        "celadon" | "osaka" => Ok(MorphHardfork::Celadon),
         "cancun" => Ok(MorphHardfork::Morph203),
         _ => Err(SchemaError::UnknownFork(name.to_string())),
     }
@@ -487,6 +497,86 @@ mod tests {
         );
     }
 
+    #[test]
+    fn morph_tx_with_authorization_list_is_modelled_as_v2() {
+        let suite: MorphTestSuite = serde_json::from_str(
+            r#"{
+              "case": {
+                "env": {
+                  "currentChainID": "0x1",
+                  "currentCoinbase": "0x0000000000000000000000000000000000000000",
+                  "currentDifficulty": "0x0",
+                  "currentGasLimit": "0x989680",
+                  "currentNumber": "0x1",
+                  "currentTimestamp": "0x1",
+                  "currentBaseFee": "0x1"
+                },
+                "pre": {},
+                "transaction": {
+                  "type": "0x7f",
+                  "nonce": "0x0",
+                  "gasLimit": ["0x186a0"],
+                  "to": "0x00000000000000000000000000000000000000f1",
+                  "value": ["0x0"],
+                  "data": ["0x"],
+                  "accessLists": [null],
+                  "maxFeePerGas": "0x10",
+                  "maxPriorityFeePerGas": "0x1",
+                  "feeTokenID": "0x1",
+                  "feeLimit": "0x3e8",
+                  "authorizationList": [{
+                    "chainId": "0x1",
+                    "address": "0x4242424242424242424242424242424242424242",
+                    "nonce": "0x0",
+                    "yParity": "0x0",
+                    "r": "0x1",
+                    "s": "0x2"
+                  }],
+                  "secretKey": "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8"
+                },
+                "post": {
+                  "Celadon": [{
+                    "indexes": { "data": 0, "gas": 0, "value": 0 },
+                    "hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    "logs": "0x0000000000000000000000000000000000000000000000000000000000000000",
+                    "expectException": null
+                  }]
+                }
+              }
+            }"#,
+        )
+        .expect("suite should parse");
+
+        let unit = suite.0.values().next().unwrap();
+        let post = &unit.post["Celadon"][0];
+        let tx = unit
+            .morph_tx_env(post, MorphHardfork::Celadon)
+            .expect("tx env should build");
+
+        assert!(tx.is_morph_tx());
+        assert_eq!(tx.version, Some(MORPH_TX_VERSION_2));
+        assert_eq!(tx.fee_token_id, Some(1));
+        assert_eq!(tx.authorization_list.len(), 1);
+
+        // The fallback L1 fee bytes must be the V2 envelope (0x7f || 0x02 || rlp)
+        // and carry the authorization list: the delegate address appears verbatim.
+        let encoded = tx.rlp_bytes.expect("fallback L1 fee bytes");
+        assert_eq!(encoded[0], 0x7f);
+        assert_eq!(encoded[1], MORPH_TX_VERSION_2);
+        let delegate = [0x42u8; 20];
+        assert!(
+            encoded.windows(20).any(|window| window == delegate),
+            "L1 fee sizing bytes must include the authorization list"
+        );
+    }
+
+    #[test]
+    fn parse_fork_maps_celadon_and_osaka() {
+        assert_eq!(parse_fork("Celadon").unwrap(), MorphHardfork::Celadon);
+        assert_eq!(parse_fork("osaka").unwrap(), MorphHardfork::Celadon);
+        assert_eq!(parse_fork("jade").unwrap(), MorphHardfork::Jade);
+    }
+
     #[test]
     fn blob_tx_without_txbytes_errors_instead_of_silently_zeroing_l1_fee() {
         let suite: MorphTestSuite = serde_json::from_str(

crates/chainspec/src/genesis.rs

@@ -40,7 +40,7 @@ impl TryFrom<&OtherFields> for MorphGenesisInfo {
 /// the Morph hardforks were activated.
 ///
 /// Note: Bernoulli and Curie use block-based activation, while Morph203, Viridian,
-/// Emerald, and Jade use timestamp-based activation (matching go-ethereum behavior).
+/// Emerald, Jade, and Celadon use timestamp-based activation (matching go-ethereum behavior).
 #[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct MorphHardforkInfo {
@@ -62,6 +62,9 @@ pub struct MorphHardforkInfo {
     /// Jade hardfork timestamp.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub jade_fork_time: Option<u64>,
+    /// Celadon hardfork timestamp.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub celadon_time: Option<u64>,
 }
 
 impl MorphHardforkInfo {
@@ -136,7 +139,8 @@ mod tests {
           "morph203Time": 3000,
           "viridianTime": 4000,
           "emeraldTime": 5000,
-          "jadeForkTime": 6000
+          "jadeForkTime": 6000,
+          "celadonTime": 7000
         }
         "#;
 
@@ -152,10 +156,32 @@ mod tests {
                 viridian_time: Some(4000),
                 emerald_time: Some(5000),
                 jade_fork_time: Some(6000),
+                celadon_time: Some(7000),
             }
         );
     }
 
+    #[test]
+    fn test_extract_morph_hardfork_info_without_celadon() {
+        // Genesis files scheduled through Jade (current mainnet/hoodi) must keep parsing.
+        let genesis_info = r#"
+        {
+          "bernoulliBlock": 0,
+          "curieBlock": 100,
+          "morph203Time": 3000,
+          "viridianTime": 4000,
+          "emeraldTime": 5000,
+          "jadeForkTime": 6000
+        }
+        "#;
+
+        let others: OtherFields = serde_json::from_str(genesis_info).unwrap();
+        let hardfork_info = MorphHardforkInfo::extract_from(&others).unwrap();
+
+        assert_eq!(hardfork_info.jade_fork_time, Some(6000));
+        assert_eq!(hardfork_info.celadon_time, None);
+    }
+
     #[test]
     fn test_extract_morph_chain_config() {
         let config_str = r#"

crates/chainspec/src/hardfork.rs

@@ -29,7 +29,7 @@
 //! ## Current State
 //!
 //! Bernoulli and Curie use block-based activation, while Morph203, Viridian,
-//! Emerald, and Jade use timestamp-based activation.
+//! Emerald, Jade, and Celadon use timestamp-based activation.
 
 use alloy_evm::revm::primitives::hardfork::SpecId;
 use alloy_hardforks::hardfork;
@@ -39,7 +39,7 @@ hardfork!(
     /// Morph-specific hardforks for network upgrades.
     ///
     /// Note: Bernoulli and Curie use block-based activation, while Morph203, Viridian,
-    /// Emerald, and Jade use timestamp-based activation (matching go-ethereum behavior).
+    /// Emerald, Jade, and Celadon use timestamp-based activation (matching go-ethereum behavior).
     #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
     #[derive(Default)]
     MorphHardfork {
@@ -56,6 +56,10 @@ hardfork!(
         /// Jade hardfork (timestamp-based).
         #[default]
         Jade,
+        /// Celadon hardfork (timestamp-based).
+        ///
+        /// Activates MorphTx version 2, which carries an EIP-7702 authorization list.
+        Celadon,
     }
 );
 
@@ -95,6 +99,12 @@ impl MorphHardfork {
     pub fn is_jade(self) -> bool {
         self >= Self::Jade
     }
+
+    /// Returns `true` if this hardfork is Celadon or later.
+    #[inline]
+    pub fn is_celadon(self) -> bool {
+        self >= Self::Celadon
+    }
 }
 
 /// Trait for querying Morph-specific hardfork activations.
@@ -141,12 +151,20 @@ pub trait MorphHardforks: EthereumHardforks {
             .active_at_timestamp(timestamp)
     }
 
+    /// Convenience method to check if Celadon hardfork is active at a given timestamp.
+    fn is_celadon_active_at_timestamp(&self, timestamp: u64) -> bool {
+        self.morph_fork_activation(MorphHardfork::Celadon)
+            .active_at_timestamp(timestamp)
+    }
+
     /// Retrieves the latest Morph hardfork active at a given block and timestamp.
     ///
     /// Note: This method checks both block-based (Bernoulli, Curie) and
-    /// timestamp-based (Morph203, Viridian, Emerald, Jade) hardforks.
+    /// timestamp-based (Morph203, Viridian, Emerald, Jade, Celadon) hardforks.
     fn morph_hardfork_at(&self, block_number: u64, timestamp: u64) -> MorphHardfork {
-        if self.is_jade_active_at_timestamp(timestamp) {
+        if self.is_celadon_active_at_timestamp(timestamp) {
+            MorphHardfork::Celadon
+        } else if self.is_jade_active_at_timestamp(timestamp) {
             MorphHardfork::Jade
         } else if self.is_emerald_active_at_timestamp(timestamp) {
             MorphHardfork::Emerald
@@ -169,14 +187,14 @@ impl From<MorphHardfork> for SpecId {
     /// The mapping must match go-ethereum Morph's EVM instruction sets:
     /// - Bernoulli/Curie/Morph203 = CANCUN gas tables (MCOPY, TSTORE/TLOAD, transient storage)
     /// - Viridian = PRAGUE (adds EIP-7702 delegation designator)
-    /// - Emerald/Jade = OSAKA (adds EIP-7939 CLZ opcode)
+    /// - Emerald/Jade/Celadon = OSAKA (adds EIP-7939 CLZ opcode)
     fn from(value: MorphHardfork) -> Self {
         match value {
             MorphHardfork::Bernoulli | MorphHardfork::Curie | MorphHardfork::Morph203 => {
                 Self::CANCUN
             }
             MorphHardfork::Viridian => Self::PRAGUE,
-            MorphHardfork::Emerald | MorphHardfork::Jade => Self::OSAKA,
+            MorphHardfork::Emerald | MorphHardfork::Jade | MorphHardfork::Celadon => Self::OSAKA,
         }
     }
 }
@@ -189,7 +207,7 @@ impl From<SpecId> for MorphHardfork {
     /// latest hardfork for the given spec level.
     fn from(spec: SpecId) -> Self {
         if spec.is_enabled_in(SpecId::OSAKA) {
-            Self::Jade
+            Self::Celadon
         } else if spec.is_enabled_in(SpecId::PRAGUE) {
             Self::Viridian
         } else {
@@ -216,6 +234,7 @@ mod tests {
         assert_eq!(SpecId::from(MorphHardfork::Viridian), SpecId::PRAGUE);
         assert_eq!(SpecId::from(MorphHardfork::Emerald), SpecId::OSAKA);
         assert_eq!(SpecId::from(MorphHardfork::Jade), SpecId::OSAKA);
+        assert_eq!(SpecId::from(MorphHardfork::Celadon), SpecId::OSAKA);
     }
 
     #[test]
@@ -227,6 +246,7 @@ mod tests {
             MorphHardfork::Viridian,
             MorphHardfork::Emerald,
             MorphHardfork::Jade,
+            MorphHardfork::Celadon,
         ];
 
         for fork in forks {
@@ -289,7 +309,15 @@ mod tests {
     fn test_specid_to_morph_hardfork_mapping() {
         assert_eq!(MorphHardfork::from(SpecId::CANCUN), MorphHardfork::Morph203);
         assert_eq!(MorphHardfork::from(SpecId::PRAGUE), MorphHardfork::Viridian);
-        assert_eq!(MorphHardfork::from(SpecId::OSAKA), MorphHardfork::Jade);
+        assert_eq!(MorphHardfork::from(SpecId::OSAKA), MorphHardfork::Celadon);
+    }
+
+    #[test]
+    fn test_is_celadon() {
+        assert!(MorphHardfork::Celadon.is_celadon());
+        assert!(MorphHardfork::Celadon.is_jade());
+        assert!(!MorphHardfork::Jade.is_celadon());
+        assert!(!MorphHardfork::Emerald.is_celadon());
     }
 
     /// SpecIds below CANCUN should map to Morph203 (the latest CANCUN-level hardfork).
@@ -313,8 +341,12 @@ mod tests {
         let spec = SpecId::from(MorphHardfork::Bernoulli);
         assert_eq!(MorphHardfork::from(spec), MorphHardfork::Morph203);
 
-        // Emerald -> OSAKA -> Jade (latest OSAKA hardfork)
+        // Emerald -> OSAKA -> Celadon (latest OSAKA hardfork)
         let spec = SpecId::from(MorphHardfork::Emerald);
-        assert_eq!(MorphHardfork::from(spec), MorphHardfork::Jade);
+        assert_eq!(MorphHardfork::from(spec), MorphHardfork::Celadon);
+
+        // Jade -> OSAKA -> Celadon (latest OSAKA hardfork)
+        let spec = SpecId::from(MorphHardfork::Jade);
+        assert_eq!(MorphHardfork::from(spec), MorphHardfork::Celadon);
     }
 }