Update expensive migration check

Author: sudo-shashank

src/networks/mod.rs

@@ -512,20 +512,19 @@ impl ChainConfig {
             .unwrap_or(0)
     }
 
-    /// Returns true if executing between `parent` and `height` (exclusive of `height`) would
-    /// cross an expensive state migration, as registered in
-    /// [`crate::state_migration::get_migrations`].
-    pub fn has_expensive_fork_between(&self, parent: ChainEpoch, height: ChainEpoch) -> bool {
+    /// Returns the epoch of an expensive state migration in `[parent, height)` if one exists.
+    pub fn expensive_fork_between(
+        &self,
+        parent: ChainEpoch,
+        height: ChainEpoch,
+    ) -> Option<ChainEpoch> {
         if parent >= height {
-            return false;
+            return None;
         }
         crate::state_migration::get_migrations::<crate::db::DbImpl>(&self.network)
             .iter()
-            .any(|(h, _)| {
-                self.height_infos
-                    .get(h)
-                    .is_some_and(|info| info.epoch >= parent && info.epoch < height)
-            })
+            .filter_map(|(h, _)| self.height_infos.get(h).map(|info| info.epoch))
+            .find(|epoch| *epoch >= parent && *epoch < height)
     }
 
     pub async fn genesis_bytes<DB: SettingsStore>(
@@ -695,11 +694,13 @@ mod tests {
     }
 
     #[test]
-    fn has_expensive_fork_between_matches_upgrade_epochs() {
+    fn expensive_fork_between_matches_upgrade_epochs() {
         let cfg = ChainConfig::mainnet();
         let shark = cfg.epoch(Height::Shark);
-        assert!(cfg.has_expensive_fork_between(shark - 1, shark + 1));
-        assert!(!cfg.has_expensive_fork_between(shark - 1, shark));
+        assert_eq!(cfg.expensive_fork_between(shark - 1, shark + 1), Some(shark));
+        assert_eq!(cfg.expensive_fork_between(shark - 1, shark), None);
+        assert_eq!(cfg.expensive_fork_between(shark, shark + 1), Some(shark));
+        assert_eq!(cfg.expensive_fork_between(shark + 1, shark + 2), None);
     }
 
     #[test]

src/rpc/error.rs

@@ -42,6 +42,9 @@ pub(crate) mod implementation_defined_errors {
     /// node. Note that it's not the same as not found, as we are explicitly not supporting it,
     /// e.g., because it's deprecated or Lotus is doing the same.
     pub(crate) const UNSUPPORTED_METHOD: i32 = -32001;
+    /// EIP-1474 "resource unavailable": explicit call targets a block whose state cannot be
+    /// served without running an expensive migration on demand. Matches Lotus `ExpensiveFork`.
+    pub(crate) const EXPENSIVE_FORK_CODE: i32 = -32002;
 }
 
 impl ServerError {
@@ -98,6 +101,9 @@ impl From<anyhow::Error> for ServerError {
         if let Some(eth_error) = error.downcast_ref::<EthErrors>() {
             return eth_error.clone().into();
         }
+        if let Some(sm_error) = error.downcast_ref::<crate::state_manager::Error>() {
+            return sm_error.clone().into();
+        }
 
         // Default fallback, not using `format!("{e:#}")` here to match Lotus error
         Self::internal_error(error.to_string(), None)
@@ -158,7 +164,6 @@ from2internal! {
     crate::key_management::Error,
     crate::libp2p::ParseError,
     crate::message_pool::Error,
-    crate::state_manager::Error,
     fil_actors_shared::fvm_ipld_amt::Error,
     futures::channel::oneshot::Canceled,
     fvm_ipld_encoding::Error,
@@ -178,6 +183,19 @@ from2internal! {
     jsonrpsee::core::client::error::Error,
 }
 
+impl From<crate::state_manager::Error> for ServerError {
+    fn from(error: crate::state_manager::Error) -> Self {
+        match error {
+            crate::state_manager::Error::ExpensiveFork { epoch } => Self::new(
+                implementation_defined_errors::EXPENSIVE_FORK_CODE,
+                error.to_string(),
+                Some(serde_json::Value::from(epoch)),
+            ),
+            other => Self::internal_error(other.to_string(), None),
+        }
+    }
+}
+
 impl From<ServerError> for ClientError {
     fn from(value: ServerError) -> Self {
         Self::Call(value.inner)
@@ -195,3 +213,50 @@ impl<T> From<tokio::sync::mpsc::error::SendError<T>> for ServerError {
         Self::internal_error(e, None)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::state_manager::Error as StateManagerError;
+
+    #[test]
+    fn expensive_fork_converts_to_server_error_with_correct_code() {
+        let err = StateManagerError::ExpensiveFork { epoch: 42 };
+        let server_err: ServerError = err.into();
+
+        assert_eq!(
+            server_err.known_code(),
+            implementation_defined_errors::EXPENSIVE_FORK_CODE.into()
+        );
+        assert_eq!(
+            server_err.inner.message(),
+            "required historical state unavailable: refusing explicit call due to state fork at epoch 42"
+        );
+        assert_eq!(
+            server_err
+                .inner
+                .data()
+                .and_then(|d| d.get().parse::<i64>().ok()),
+            Some(42)
+        );
+    }
+
+    #[test]
+    fn expensive_fork_via_anyhow_preserves_code() {
+        let sm_err = StateManagerError::ExpensiveFork { epoch: 99 };
+        let anyhow_err: anyhow::Error = sm_err.into();
+        let server_err: ServerError = anyhow_err.into();
+
+        assert_eq!(
+            server_err.known_code(),
+            implementation_defined_errors::EXPENSIVE_FORK_CODE.into()
+        );
+        assert_eq!(
+            server_err
+                .inner
+                .data()
+                .and_then(|d| d.get().parse::<i64>().ok()),
+            Some(99)
+        );
+    }
+}

src/rpc/methods/eth.rs

@@ -1853,15 +1853,11 @@ async fn apply_message(
     msg: Message,
 ) -> Result<ApiInvocResult, Error> {
     if let Some(ts) = &tipset
-        && ts.epoch() > 0
-    {
-        let parent = ctx.chain_index().load_required_tipset(ts.parents())?;
-        if ctx
+        && let Some(epoch) = ctx
             .chain_config()
-            .has_expensive_fork_between(parent.epoch(), ts.epoch() + 1)
-        {
-            return Err(crate::state_manager::Error::ExpensiveFork.into());
-        }
+            .expensive_fork_between(ts.epoch(), ts.epoch() + 1)
+    {
+        return Err(crate::state_manager::Error::ExpensiveFork { epoch }.into());
     }
 
     let (invoc_res, _) = ctx

src/rpc/methods/state.rs

@@ -90,16 +90,15 @@ impl StateCall {
             .chain_store()
             .load_required_tipset_or_heaviest(&tsk)?;
 
-        // Match Lotus' `StateCall` behavior: if the call refuses due to an expensive
-        // state fork between the parent and the target tipset, walk back to the parent
-        // tipset and retry. This loop terminates when the call returns a non-`ExpensiveFork`
-        // result (success or different error), or when we fail to load the parent tipset
-        // (e.g. we walked back past genesis).
+        // Match Lotus' `StateCall` behavior: parent-state `Call` refuses when a migration spans
+        // the parent→tipset window; walk back to the parent tipset and retry. This does not
+        // serve U+1 at the requested tipset (unlike `eth_call`, which uses explicit tipset
+        // state).
         //
         // See: <https://github.com/filecoin-project/lotus/blob/797feebc63bfbd4fdfb742b674c97bfb7846cccb/node/impl/full/state.go#L147>
         loop {
             match state_manager.call(message, Some(tipset.shallow_clone())) {
-                Err(crate::state_manager::Error::ExpensiveFork) => {
+                Err(crate::state_manager::Error::ExpensiveFork { .. }) => {
                     tipset = state_manager
                         .chain_index()
                         .load_required_tipset(tipset.parents())

src/state_manager/errors.rs

@@ -3,18 +3,21 @@
 
 use std::fmt::{Debug, Display};
 
+use crate::shim::clock::ChainEpoch;
 use thiserror::Error;
 use tokio::task::JoinError;
 
 /// State manager error
-#[derive(Debug, PartialEq, Error)]
+#[derive(Clone, Debug, PartialEq, Error)]
 pub enum Error {
     /// Error originating from state
     #[error("{0}")]
     State(String),
     /// Refusing explicit call due to an expensive state migration at the requested epoch.
-    #[error("refusing explicit call due to state fork at epoch")]
-    ExpensiveFork,
+    #[error(
+        "required historical state unavailable: refusing explicit call due to state fork at epoch {epoch}"
+    )]
+    ExpensiveFork { epoch: ChainEpoch },
     /// Other state manager error
     #[error("{0}")]
     Other(String),

src/state_manager/message_simulation.rs

@@ -26,24 +26,37 @@ impl StateManager {
 
         let tipset = if let Some(ts) = tipset {
             if ts.epoch() > 0 {
-                let parent = self
-                    .chain_index()
-                    .load_required_tipset(ts.parents())
-                    .map_err(Error::other)?;
-                if chain_config.has_expensive_fork_between(parent.epoch(), ts.epoch() + 1) {
-                    return Err(Error::ExpensiveFork);
+                // Lotus `callInternal` uses a parent-based fork floor for parent-state calls
+                // (`state_cid` unset) and a tipset-height floor for explicit-state calls (Eth
+                // `TipSetState` path).
+                let (fork_floor, fork_height) = if state_cid.is_some() {
+                    (ts.epoch(), ts.epoch() + 1)
+                } else {
+                    let parent = self
+                        .chain_index()
+                        .load_required_tipset(ts.parents())
+                        .map_err(Error::other)?;
+                    (parent.epoch(), ts.epoch() + 1)
+                };
+                if let Some(epoch) =
+                    chain_config.expensive_fork_between(fork_floor, fork_height)
+                {
+                    return Err(Error::ExpensiveFork { epoch });
                 }
             }
             ts
         } else {
             // Search back till we find a height with no fork, or we reach the beginning.
+            // Uses the parent-based window (Lotus `callInternal` with `ts == nil`).
             let mut heaviest_ts = self.heaviest_tipset();
             while heaviest_ts.epoch() > 0 {
                 let parent = self
                     .chain_index()
                     .load_required_tipset(heaviest_ts.parents())
                     .map_err(Error::other)?;
-                if !chain_config.has_expensive_fork_between(parent.epoch(), heaviest_ts.epoch() + 1)
+                if chain_config
+                    .expensive_fork_between(parent.epoch(), heaviest_ts.epoch() + 1)
+                    .is_some()
                 {
                     break;
                 }

src/tool/subcommands/api_cmd/api_compare_tests.rs

@@ -2455,7 +2455,7 @@ fn eth_expensive_fork_error_tests(store: Arc<ManyCar>) -> anyhow::Result<Vec<Rpc
             .max()
             .ok_or_else(|| anyhow::anyhow!("calibnet must define at least one expensive fork"))?;
 
-    Ok(vec![
+    let mut tests = vec![
         RpcTest::identity(EthCall::request((
             EthCallMessage::default(),
             BlockNumberOrHash::from_block_number(expensive_fork_epoch),
@@ -2469,7 +2469,20 @@ fn eth_expensive_fork_error_tests(store: Arc<ManyCar>) -> anyhow::Result<Vec<Rpc
             Some(BlockNumberOrHash::from_block_number(expensive_fork_epoch)),
         ))?)
         .policy_on_rejected(PolicyOnRejected::PassWithQuasiIdenticalError),
-    ])
+    ];
+
+    // eth_call must succeed at U+1 when migration ran at U.
+    let after_fork_epoch = expensive_fork_epoch + 1;
+    if after_fork_epoch <= heaviest_tipset.epoch() {
+        tests.push(
+            RpcTest::identity(EthCall::request((
+                EthCallMessage::default(),
+                BlockNumberOrHash::from_block_number(after_fork_epoch),
+            ))?),
+        );
+    }
+
+    Ok(tests)
 }
 
 // Extract tests that use chain-specific data such as block CIDs or message