Skip to content

Impl state fork handler in state manager call_raw#7061

Open
sudo-shashank wants to merge 13 commits into
mainfrom
shashank/fix-call-raw
Open

Impl state fork handler in state manager call_raw#7061
sudo-shashank wants to merge 13 commits into
mainfrom
shashank/fix-call-raw

Conversation

@sudo-shashank
Copy link
Copy Markdown
Contributor

@sudo-shashank sudo-shashank commented May 15, 2026

Summary of changes

Changes introduced in this pull request:

  • Impl state fork handler and expensive fork check.

Reference issue to close (if applicable)

Closes #6446
Closes #5965

Other information and links

Change checklist

  • I have performed a self-review of my own code,
  • I have made corresponding changes to the documentation. All new code adheres to the team's documentation standards,
  • I have added tests that prove my fix is effective or that my feature works (if possible),
  • I have made sure the CHANGELOG is up-to-date. All user-facing changes should be reflected in this document.

Outside contributions

  • I have read and agree to the CONTRIBUTING document.
  • I have read and agree to the AI Policy document. I understand that failure to comply with the guidelines will lead to rejection of the pull request.

Summary by CodeRabbit

  • New Features

    • Explicitly model and mark “expensive” state-migration epochs in chain configuration.
    • Reject on-demand state calls that target expensive migration epochs and return a clear expensive-fork error.
    • RPC state call retry: automatically fall back to parent epochs when an expensive-fork rejection occurs.
  • Tests

    • Added snapshot tests covering expensive-fork error scenarios for ETH RPC calls.

Review Change Stack

@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented May 15, 2026

Walkthrough

Forest now detects and rejects RPC calls that would trigger expensive protocol upgrade migrations. Network configuration marks which protocol heights are expensive via is_expensive_migration() and ChainConfig::has_expensive_fork_between(). StateManager::call_raw is refactored to internally check for expensive forks and compute state via migrations. ETH RPC and StateCall integrate guards and retry logic matching Lotus behavior, with test fixtures validating expensive fork rejection paths.

Changes

Expensive Fork Handling in State Simulation

Layer / File(s) Summary
Network infrastructure for expensive migration markers
src/networks/mod.rs
is_expensive_migration() predicate identifies expensive protocol upgrades; HeightInfo.expensive field is populated via the predicate and macro; ChainConfig.has_expensive_fork_between() queries expensive forks within an epoch range; tests validate marker consistency.
Error handling for expensive fork refusal
src/state_manager/errors.rs
New Error::ExpensiveFork variant represents explicit call refusal when expensive state migration would be triggered.
Message simulation refactoring with expensive fork handling
src/state_manager/message_simulation.rs
StateManager::call_raw refactored to accept optional tipset and state cid; internally derives effective tipset while checking expensive fork boundaries; computes state cid via run_state_migrations; derives chain_rand from resolved tipset; public call and call_on_state delegates refactored to new signature.
ETH RPC guards for expensive fork rejection
src/rpc/methods/eth.rs
apply_message adds pre-execution guard checking parent and target epoch against has_expensive_fork_between; returns Error::ExpensiveFork when detected; error formatting updated in eth_estimate_gas to use message().
StateCall retry loop for expensive forks
src/rpc/methods/state.rs
StateCall::run implements Lotus-compatible retry: on ExpensiveFork error, loads parent tipset and retries; terminates on non-ExpensiveFork result; parent-tipset load errors wrapped with contextual messages.
Test fixtures for expensive fork scenarios
src/tool/subcommands/api_cmd/api_compare_tests.rs
eth_expensive_fork_error_tests generates ETH call and estimate_gas tests targeting expensive fork epochs; snapshot_tests extended to include generated fixtures; store cloning adjusted for ownership consistency.

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~25 minutes

Suggested reviewers

  • hanabi1224
  • akaladarshi
🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 warning)

Check name Status Explanation Resolution
Docstring Coverage ⚠️ Warning Docstring coverage is 20.00% which is insufficient. The required threshold is 80.00%. Write docstrings for the functions missing them to satisfy the coverage threshold.
✅ Passed checks (4 passed)
Check name Status Explanation
Description Check ✅ Passed Check skipped - CodeRabbit’s high-level summary is enabled.
Title check ✅ Passed The title accurately describes the main change: implementation of state fork handler in state manager's call_raw method, which is the core objective across all file modifications.
Linked Issues check ✅ Passed All code changes comprehensively address both linked issues: fork handler with state migrations is implemented in call_raw (#6446), and expensive fork detection with error returns is added across RPC methods (#5965).
Out of Scope Changes check ✅ Passed All changes are directly scoped to implementing fork handling and expensive fork detection; no unrelated modifications detected across state manager, networks config, RPC methods, or test utilities.

✏️ Tip: You can configure your own custom pre-merge checks in the settings.

✨ Finishing Touches
📝 Generate docstrings
  • Create stacked PR
  • Commit on current branch
🧪 Generate unit tests (beta)
  • Create PR with unit tests
  • Commit unit tests in branch shashank/fix-call-raw
✨ Simplify code
  • Create PR with simplified code
  • Commit simplified code in branch shashank/fix-call-raw

Comment @coderabbitai help to get the list of available commands and usage tips.

@sudo-shashank sudo-shashank changed the title Use state fork handler in state manager call_raw Use prepare_parent_state in state manager call_raw May 15, 2026
Copy link
Copy Markdown
Contributor

@coderabbitai coderabbitai Bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Actionable comments posted: 1

🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/state_manager/message_simulation.rs`:
- Around line 42-44: The call to exec.prepare_parent_state(genesis_timestamp,
VMTrace::NotTraced, &mut no_cb)? lacks any error context; change it to use
anyhow::Context so failures include call-site info (e.g., use
exec.prepare_parent_state(...).context(format!("failed to prepare parent state
for genesis_timestamp={}", genesis_timestamp))?), ensuring the returned
(state_cid, _, _) bind remains the same and still handles the Result from
prepare_parent_state with context attached.
🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

  • Push a commit to this branch (recommended)
  • Create a new PR with the fixes

ℹ️ Review info
⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro

Run ID: 418976d3-f7ec-4592-a04e-233e6206d71f

📥 Commits

Reviewing files that changed from the base of the PR and between c89d3e3 and ad5e956.

📒 Files selected for processing (1)
  • src/state_manager/message_simulation.rs

Comment thread src/state_manager/message_simulation.rs Outdated
@sudo-shashank sudo-shashank changed the title Use prepare_parent_state in state manager call_raw Impl state fork handler in state manager call_raw May 18, 2026
Copy link
Copy Markdown
Contributor

@coderabbitai coderabbitai Bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Actionable comments posted: 3

🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/networks/mod.rs`:
- Around line 542-550: The has_expensive_fork_between function incorrectly
includes the parent epoch in its search window causing a migration at parent to
make the next tipset appear to require migration; update the lower bound check
so it excludes parent by using info.epoch > parent (instead of info.epoch >=
parent) when scanning self.height_infos.values() for info.expensive, i.e. change
the predicate in has_expensive_fork_between to info.expensive && info.epoch >
parent && info.epoch < height so parent-side migrations are not double-counted.

In `@src/state_manager/errors.rs`:
- Around line 15-17: The error message for the ExpensiveFork variant is not
self-contained because it mentions "at epoch" but the variant carries no epoch;
fix by either (A) adding an epoch field to the variant (e.g., change
ExpensiveFork to ExpensiveFork { epoch: u64 } or similar type and update the
#[error(...)] to include the epoch placeholder like #[error("refusing explicit
call due to state fork at epoch {epoch}")] and then update all places that
construct ExpensiveFork to pass the epoch, or (B) remove the dangling suffix by
changing the #[error(...)] text to a self-contained message such as
#[error("refusing explicit call due to state fork")]; touch the ExpensiveFork
variant and its usages accordingly to keep types/constructors consistent.

In `@src/state_manager/message_simulation.rs`:
- Around line 30-56: The code currently performs the expensive-fork check
(chain_config.has_expensive_fork_between) and runs migration prep even when the
caller supplied a state (state_cid is Some), which can reject or re-mutate a
caller-provided post-fork state; in call_on_state, guard the expensive-fork
rejection and run_state_migrations() so they only execute when
state_cid.is_none() (i.e., when we derive state from a tipset), by moving the
chain_config.has_expensive_fork_between checks and the run_state_migrations()
calls inside the state_cid.is_none() branch; apply the same change for the other
occurrence around the code referenced at 58-79 and keep references to
chain_index().load_required_tipset, has_expensive_fork_between,
run_state_migrations, and call_on_state to locate the spots to change.
🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

  • Push a commit to this branch (recommended)
  • Create a new PR with the fixes

ℹ️ Review info
⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro

Run ID: 8082d114-8347-4a81-b4bb-2fa3b521a995

📥 Commits

Reviewing files that changed from the base of the PR and between b391f54 and c664609.

📒 Files selected for processing (3)
  • src/networks/mod.rs
  • src/state_manager/errors.rs
  • src/state_manager/message_simulation.rs

Comment thread src/networks/mod.rs
Comment thread src/state_manager/errors.rs
Comment thread src/state_manager/message_simulation.rs
@sudo-shashank sudo-shashank force-pushed the shashank/fix-call-raw branch from c2ff120 to 23e2128 Compare May 19, 2026 07:24
@sudo-shashank sudo-shashank added the RPC requires calibnet RPC checks to run on CI label May 19, 2026
@sudo-shashank sudo-shashank marked this pull request as ready for review May 20, 2026 06:04
@sudo-shashank sudo-shashank requested a review from a team as a code owner May 20, 2026 06:04
@sudo-shashank sudo-shashank requested review from akaladarshi and hanabi1224 and removed request for a team May 20, 2026 06:04
Copy link
Copy Markdown
Contributor

@coderabbitai coderabbitai Bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Actionable comments posted: 1

🧹 Nitpick comments (1)
src/networks/mod.rs (1)

731-737: ⚡ Quick win

Pin the inclusive lower-bound case in this regression test.

This currently locks in the exclusive upper bound only. Adding an assertion like assert!(cfg.has_expensive_fork_between(shark, shark + 1)); would protect the intended [parent, height) behavior from regressing again.

Based on learnings: ChainConfig::has_expensive_fork_between(parent, height) intentionally uses an inclusive lower bound matching Lotus’s [parent, height) semantics.

🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/networks/mod.rs` around lines 731 - 737, Update the test
has_expensive_fork_between_matches_upgrade_epochs to pin the inclusive
lower-bound case by adding an assertion that the fork exists at the lower bound:
insert assert!(cfg.has_expensive_fork_between(shark, shark + 1)); inside the
test (the test uses ChainConfig::mainnet(), variable shark =
cfg.epoch(Height::Shark)) so update that function to include this new assertion
that calls ChainConfig::has_expensive_fork_between with (shark, shark + 1).
🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/tool/subcommands/api_cmd/api_compare_tests.rs`:
- Around line 2450-2456: The code computing expensive_fork_epoch uses
.max().expect(...) which can panic; update this in the helper that returns
anyhow::Result to return an error instead of aborting: replace the
.max().expect(...) pattern on
chain_config.height_infos.values().filter(...).map(...).max() with
.ok_or_else(|| anyhow::anyhow!("calibnet must define at least one expensive
fork"))? so the function returns Err(...) when no epoch is found, propagating
the anyhow::Result; keep references to expensive_fork_epoch, chain_config,
heaviest_tipset, and height_infos so the change is localized.

---

Nitpick comments:
In `@src/networks/mod.rs`:
- Around line 731-737: Update the test
has_expensive_fork_between_matches_upgrade_epochs to pin the inclusive
lower-bound case by adding an assertion that the fork exists at the lower bound:
insert assert!(cfg.has_expensive_fork_between(shark, shark + 1)); inside the
test (the test uses ChainConfig::mainnet(), variable shark =
cfg.epoch(Height::Shark)) so update that function to include this new assertion
that calls ChainConfig::has_expensive_fork_between with (shark, shark + 1).
🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

  • Push a commit to this branch (recommended)
  • Create a new PR with the fixes

ℹ️ Review info
⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro

Run ID: 4821a8ea-e361-4550-aaaf-255a36880eac

📥 Commits

Reviewing files that changed from the base of the PR and between b391f54 and 6621857.

📒 Files selected for processing (6)
  • src/networks/mod.rs
  • src/rpc/methods/eth.rs
  • src/rpc/methods/state.rs
  • src/state_manager/errors.rs
  • src/state_manager/message_simulation.rs
  • src/tool/subcommands/api_cmd/api_compare_tests.rs

Comment thread src/tool/subcommands/api_cmd/api_compare_tests.rs Outdated
@codecov
Copy link
Copy Markdown

codecov Bot commented May 20, 2026

Codecov Report

❌ Patch coverage is 67.85714% with 27 lines in your changes missing coverage. Please review.
✅ Project coverage is 64.25%. Comparing base (3f55831) to head (c982c0f).
✅ All tests successful. No failed tests found.

Files with missing lines Patch % Lines
src/state_manager/message_simulation.rs 60.46% 15 Missing and 2 partials ⚠️
src/rpc/methods/state.rs 28.57% 4 Missing and 1 partial ⚠️
src/rpc/methods/eth.rs 60.00% 3 Missing and 1 partial ⚠️
src/networks/mod.rs 95.83% 1 Missing ⚠️
Additional details and impacted files
Files with missing lines Coverage Δ
src/state_manager/errors.rs 60.00% <ø> (+20.00%) ⬆️
src/networks/mod.rs 89.40% <95.83%> (+0.35%) ⬆️
src/rpc/methods/eth.rs 65.68% <60.00%> (+<0.01%) ⬆️
src/rpc/methods/state.rs 44.43% <28.57%> (-0.07%) ⬇️
src/state_manager/message_simulation.rs 76.21% <60.46%> (-4.92%) ⬇️

... and 15 files with indirect coverage changes


Continue to review full report in Codecov by Sentry.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 3f55831...c982c0f. Read the comment docs.

🚀 New features to boost your workflow:
  • 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

Copy link
Copy Markdown
Contributor

@coderabbitai coderabbitai Bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🧹 Nitpick comments (1)
src/tool/subcommands/api_cmd/api_compare_tests.rs (1)

2456-2456: ⚡ Quick win

Enhance error message with diagnostic context.

The change from .expect() to .ok_or_else() correctly addresses the past review feedback. However, the error message could be more diagnostic by including the heaviest tipset epoch, as suggested in the original review comment.

📋 Suggested improvement for diagnostics
-        .ok_or_else(|| anyhow::anyhow!("calibnet must define at least one expensive fork"))?;
+        .ok_or_else(|| {
+            anyhow::anyhow!(
+                "no expensive fork epoch <= heaviest tipset epoch {} for calibnet snapshot",
+                heaviest_tipset.epoch()
+            )
+        })?;
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/tool/subcommands/api_cmd/api_compare_tests.rs` at line 2456, The error
created by .ok_or_else currently uses a generic message "calibnet must define at
least one expensive fork"; update the closure to include diagnostic context by
appending the heaviest tipset epoch (e.g., heaviest_tipset_epoch or
heaviest_tipset.epoch()) so the error shows the epoch value when no expensive
fork is found; locate the call site where .ok_or_else(|| anyhow::anyhow!(...))
is used and interpolate the existing heaviest tipset variable into the anyhow
message to produce a clearer, actionable error.
🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Nitpick comments:
In `@src/tool/subcommands/api_cmd/api_compare_tests.rs`:
- Line 2456: The error created by .ok_or_else currently uses a generic message
"calibnet must define at least one expensive fork"; update the closure to
include diagnostic context by appending the heaviest tipset epoch (e.g.,
heaviest_tipset_epoch or heaviest_tipset.epoch()) so the error shows the epoch
value when no expensive fork is found; locate the call site where .ok_or_else(||
anyhow::anyhow!(...)) is used and interpolate the existing heaviest tipset
variable into the anyhow message to produce a clearer, actionable error.

ℹ️ Review info
⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro

Run ID: 3494d18e-f244-4632-b2a5-c3084f080270

📥 Commits

Reviewing files that changed from the base of the PR and between 6621857 and 548b665.

📒 Files selected for processing (1)
  • src/tool/subcommands/api_cmd/api_compare_tests.rs

Comment thread src/networks/mod.rs
pub const fn is_expensive_migration(height: Height) -> bool {
matches!(
height,
Height::Assembly
Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

How about *Fix migrations on calibnet?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

RPC requires calibnet RPC checks to run on CI

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Impl state fork handler in state manager call_raw Investigate expensive fork handling in Forest

2 participants