Reviewing files that changed from the base of the PR and between 06e744d and ac98ef5.

• src/chain/store/chain_store.rs (3 hunks)
• src/chain_sync/chain_follower.rs (1 hunks)
• src/chain_sync/sync_status.rs (1 hunks)
• src/chain_sync/tipset_syncer.rs (4 hunks)
• src/fil_cns/validation.rs (2 hunks)
• src/interpreter/fvm2.rs (1 hunks)
• src/interpreter/fvm3.rs (1 hunks)
• src/interpreter/fvm4.rs (1 hunks)
• src/libp2p/service.rs (2 hunks)
• src/rpc/methods/eth/filter/mod.rs (1 hunks)
• src/rpc/methods/f3.rs (1 hunks)
• src/rpc/methods/gas.rs (1 hunks)
• src/rpc/methods/miner.rs (1 hunks)
• src/rpc/methods/state.rs (2 hunks)
• src/rpc/methods/wallet.rs (1 hunks)
• src/rpc/mod.rs (1 hunks)
• src/state_manager/circulating_supply.rs (1 hunks)
• src/state_manager/mod.rs (13 hunks)

• GitHub Check: Build forest binaries on Linux AMD64
• GitHub Check: tests
• GitHub Check: tests-release
• GitHub Check: All lint checks
• GitHub Check: cargo-publish-dry-run
• GitHub Check: Build MacOS
• GitHub Check: Build Ubuntu

src/rpc/methods/f3.rs (1)

449-452: Using borrowed tipset here correctly matches the new resolve_to_deterministic_address API

ts is already a &Arc<Tipset>, so passing it directly avoids an unnecessary Arc clone while staying compatible with the updated resolve_to_deterministic_address signature.

src/libp2p/service.rs (2)

439-446: Switching handle_network_message to &PeerManager is type‑safe and avoids Arc noise

Callers now pass &self.peer_manager (an Arc<PeerManager> field), which deref‑coerces to &PeerManager, so this removes an extra Arc layer in the signature without changing behavior.

---

865-870: Borrowing PeerManager in handle_forest_behaviour_event is consistent with new call sites

Accepting peer_manager: &PeerManager aligns with the updated run loop usage (&self.peer_manager) and keeps the handler free of unnecessary Arc cloning.

src/rpc/methods/wallet.rs (1)

250-255: WalletSignMessage now correctly borrows the heaviest tipset

Passing &ts into resolve_to_deterministic_address matches the updated &Arc<Tipset> signature and removes an unnecessary Arc clone without changing semantics.

src/rpc/methods/eth/filter/mod.rs (1)

293-307: Reusing the borrowed tipset in collect_events avoids redundant Arc cloning

tipset is already a &Arc<Tipset>, and resolve_to_deterministic_address now takes &Arc<Tipset>, so passing it directly is correct and more efficient than cloning the Arc.

src/chain_sync/chain_follower.rs (1)

850-857: validate_tipset now borrows the StateManager Arc instead of taking ownership

Passing &state_manager into validate_tipset matches the updated signature and removes an extra Arc clone per task, without changing validation behavior.

src/interpreter/fvm3.rs (1)

67-75: Borrowing chain_index/chain_config/heaviest_tipset into get_lookback_tipset_for_round is correct

Using &self.chain_index, &self.chain_config, and &self.heaviest_tipset matches the refactored get_lookback_tipset_for_round signature and avoids cloning these Arcs while preserving behavior.

src/rpc/methods/gas.rs (1)

115-123: estimate_gas_premium now calls messages_for_tipset_with_cache using borrowed store and cache

Switching to data.store() and &data.msgs_in_tipset aligns with the updated messages_for_tipset_with_cache signature, eliminating extra Arc clones without changing gas premium calculation logic.

src/chain_sync/tipset_syncer.rs (4)

100-121: Arc borrowing change in validate_tipset looks correct

Switching state_manager to &Arc<StateManager<DB>> and cloning it only when spawning validate_block keeps the async tasks 'static while avoiding an extra Arc clone at the call site. The ownership and lifetimes still line up, and chainstore continues to be used only on the sync path for add_to_tipset_tracker.

---

207-215: get_lookback_tipset_for_round argument wiring is consistent

Passing state_manager.chain_store().chain_index() and state_manager.chain_config() by reference, plus &base_tipset, matches how the helper is used elsewhere (e.g., miner_get_base_info). The mapping to a state root handle and its later use in get_miner_work_addr preserves the previous behavior.

---

352-370: BLS pubkey lookup now cleanly reuses the shared blockstore Arc

Using let db = state_manager.blockstore(); and then calling StateManager::get_bls_public_key(db, ...) avoids cloning the blockstore Arc at the call site while keeping the helper responsible for owning its own Arc clone. This keeps the interface tidy and aligns with other state-manager helpers.

---

483-488: Message-root computation correctly switches to borrowed blockstore

Calling TipsetValidator::compute_msg_root(state_manager.blockstore(), ...) instead of passing an owned clone reduces unnecessary Arc churn and is consistent with how other helpers now accept &Arc<DB>. No behavior change to the header vs. computed root comparison logic.

src/state_manager/mod.rs (6)

440-451: get_all_sectors receiver change is consistent

Switching get_all_sectors to take &self (instead of self: &Arc<Self>) matches the rest of the synchronous state-accessors in this impl and doesn’t affect behavior; it still walks through get_actor and miner::State::load as before.

---

582-668: call_raw / call borrowing self and tipset is an improvement

Using &self and &Arc<Tipset> in call_raw, and having call construct a local Arc<Tipset> and pass &ts, removes unnecessary Arc indirection on the API without changing semantics. The VM ExecutionContext still receives an owned Arc::clone(tipset), so the lifetime and ownership over the heaviest tipset are preserved.

---

710-748: Circulating-supply call now reuses the shared blockstore handle

Passing self.blockstore() into get_vm_circulating_supply in call_with_gas aligns with the broader refactor of using borrowed Arc<DB> everywhere. That avoids a redundant Arc clone while leaving the VM construction path unchanged.

---

1550-1585: Range-validation helpers now use &self cleanly

validate_range and validate_tipsets no longer require self: &Arc<Self>, which makes them simpler to call from both Arc-managed and direct contexts. They still pass cloned Arc handles (chain index, chain config, beacon, engine) into the free validate_tipsets function, so the actual validation behavior is untouched.

---

1588-1622: Search helpers now consistently borrow self

search_for_message using &self and keeping the search logic in check_search / search_back_for_message unchanged is a straightforward API cleanup. The interplay between “from” tipset, heaviest tipset, and look-back semantics remains the same.

---

1265-1282: get_bls_public_key signature matches new call sites

Taking db: &Arc<DB> lets callers pass state_manager.blockstore() directly (as in check_block_messages), while the helper remains responsible for cloning the Arc for StateTree::new_from_root. Internally it still resolves to a key address and enforces the “must be BLS” invariant, so behavior is preserved with slightly cheaper call plumbing.

src/interpreter/fvm4.rs (1)

67-75: Borrowing Arc parameters here is correct and avoids extra clones

Passing &self.chain_index, &self.chain_config, and &self.heaviest_tipset matches the updated ChainStore::get_lookback_tipset_for_round signature without changing behavior.

src/interpreter/fvm2.rs (1)

63-71: Consistent Arc borrowing in lookback call

Using &self.chain_index, &self.chain_config, and &self.heaviest_tipset aligns with the new get_lookback_tipset_for_round API and removes unnecessary Arc cloning.

src/rpc/mod.rs (1)

486-488: Expose the underlying Arc<DB> from RPCState::store

Returning &Arc<DB> directly from chain_store().blockstore() is consistent with ChainStore’s API and avoids extra indirection; existing callers can still treat it as a Blockstore via deref.

src/chain_sync/sync_status.rs (1)

141-185: Accepting &StateManager<DB> instead of &Arc<StateManager<DB>> is a safe simplification

The method body only needs a shared reference, so dropping the Arc from the signature reduces coupling and avoids needless Arc cloning at call sites while preserving behavior.

src/rpc/methods/miner.rs (1)

115-132: Miner lookback state now uses borrowed Arc inputs correctly

Passing ctx.chain_index(), ctx.chain_config(), and &parent_tipset into ChainStore::get_lookback_tipset_for_round, then wrapping the returned state root in Arc keeps the original semantics while avoiding redundant Arc clones.

src/fil_cns/validation.rs (1)

71-176: Async validation refactor correctly switches to borrowed/Arc inputs

The updated get_lookback_tipset_for_round call and the spawn_blocking/async closures now:

• Move/cloned Arc state (state_manager, base_tipset, block, prev_beacon, lookback_state) into the tasks, and
• Pass shared references (&StateManager<_>, &Tipset, &Cid, &BeaconEntry, &Address) into the validation helpers.

This removes unnecessary Arc cloning while keeping lifetimes and concurrency semantics sound.

src/rpc/methods/state.rs (2)

84-95: StateCall::run now correctly abstracts over StateManager without exposing Arc

Taking state_manager: &StateManager<DB> and calling it via &ctx.state_manager keeps the call behavior identical while hiding Arc from the API surface and avoiding redundant clones.

---

196-205: Pass tipset by reference into resolve_to_deterministic_address

Switching to resolve_to_deterministic_address(address, &ts) avoids moving/cloning the Arc<Tipset> and matches an interface that works on a borrowed tipset, without changing the call’s semantics.

src/chain/store/chain_store.rs (2)

321-381: Refactored lookback helper cleanly borrows Arc inputs

get_lookback_tipset_for_round now:

• Accepts &Arc<ChainIndex<_>>, &Arc<ChainConfig>, and &Arc<Tipset>,
• Clones those Arcs only where needed (apply_block_messages, return value).

This preserves the prior logic while avoiding unnecessary Arc moves.

---

617-632: messages_for_tipset never populates applied/balances, so it always yields no messages

The Arc-borrowing changes here look correct, but there is a pre‑existing logic bug in messages_for_tipset:

• applied and balances start empty.
• They are only initialized when applied.contains_key(from_address) is true:

  if applied.contains_key(from_address) {
      let actor_state = state
          .get_actor(from_address)?
          .ok_or_else(|| Error::Other("Actor state not found".to_string()))?;
      applied.insert(*from_address, actor_state.sequence);
      balances.insert(*from_address, actor_state.balance.clone().into());
  }

• Because nothing is ever inserted before this check, it never runs for a new sender; applied.get_mut(from_address) then returns None, and the message is skipped.
• As a result, messages_for_tipset (and anything using messages_for_tipset_with_cache) will always return an empty Vec<ChainMessage> for a fresh tipset.

This contradicts the intended Lotus‑style behavior of initializing sender state on first encounter and then walking sequential nonces.

Flip the condition so initialization happens for first‑seen senders:

-                if applied.contains_key(from_address) {
+                if !applied.contains_key(from_address) {
                     let actor_state = state
                         .get_actor(from_address)?
                         .ok_or_else(|| Error::Other("Actor state not found".to_string()))?;
                     applied.insert(*from_address, actor_state.sequence);
                     balances.insert(*from_address, actor_state.balance.clone().into());
                 }

With this change, the rest of the nonce/balance filtering logic becomes effective and messages_for_tipset will actually surface valid messages as intended.

Also applies to: 637-692

⛔ Skipped due to learnings

Learnt from: hanabi1224
Repo: ChainSafe/forest PR: 5867
File: src/ipld/util.rs:461-487
Timestamp: 2025-08-08T12:11:55.266Z
Learning: Forest (src/ipld/util.rs, Rust): In UnorderedChainStream::poll_next, dropping `extract_sender` (when no more tipsets and the extract queue is empty) is the intended shutdown signal for workers. Any subsequent attempt to enqueue work after this drop is a logic error and should be treated as an error; do not change `send()` to ignore a missing sender.

Learnt from: hanabi1224
Repo: ChainSafe/forest PR: 6167
File: src/tool/subcommands/state_compute_cmd.rs:89-91
Timestamp: 2025-10-17T14:24:47.046Z
Learning: In `src/tool/subcommands/state_compute_cmd.rs`, when using `ReadOpsTrackingStore` to generate minimal snapshots, `HEAD_KEY` should be written to `db.tracker` (not `db` itself) before calling `export_forest_car()`, because the export reads from the tracker MemoryDB which accumulates only the accessed data during computation.