Integrate v19 fil-actor-states (#5051)

Cargo.toml

@@ -60,19 +60,19 @@ directories = "5"
 displaydoc = "0.2"
 ethereum-types = "0.15"
 ez-jsonrpc-types = "0.5"
-fil_actor_account_state = { version = "18" }
-fil_actor_cron_state = { version = "18" }
-fil_actor_datacap_state = { version = "18" }
-fil_actor_evm_state = { version = "18" }
-fil_actor_init_state = { version = "18" }
-fil_actor_market_state = { version = "18" }
-fil_actor_miner_state = { version = "18" }
-fil_actor_multisig_state = { version = "18" }
-fil_actor_power_state = { version = "18" }
-fil_actor_reward_state = { version = "18" }
-fil_actor_system_state = { version = "18" }
-fil_actor_verifreg_state = { version = "18" }
-fil_actors_shared = { version = "18", features = ["json"] }
+fil_actor_account_state = { version = "19" }
+fil_actor_cron_state = { version = "19" }
+fil_actor_datacap_state = { version = "19" }
+fil_actor_evm_state = { version = "19" }
+fil_actor_init_state = { version = "19" }
+fil_actor_market_state = { version = "19" }
+fil_actor_miner_state = { version = "19" }
+fil_actor_multisig_state = { version = "19" }
+fil_actor_power_state = { version = "19" }
+fil_actor_reward_state = { version = "19" }
+fil_actor_system_state = { version = "19" }
+fil_actor_verifreg_state = { version = "19" }
+fil_actors_shared = { version = "19", features = ["json"] }
 flume = { workspace = true }
 fs_extra = "1"
 futures = { workspace = true }

src/rpc/error.rs

@@ -135,6 +135,7 @@ from2internal! {
     fil_actors_shared::v13::ActorError,
     fil_actors_shared::v14::ActorError,
     fil_actors_shared::v15::ActorError,
+    fil_actors_shared::v16::ActorError,
     serde_json::Error,
     jsonrpsee::core::client::error::Error,
 }

src/rpc/methods/f3.rs

@@ -16,7 +16,8 @@ use super::wallet::WalletSign;
 use crate::shim::actors::{
     convert::{
         from_policy_v13_to_v10, from_policy_v13_to_v11, from_policy_v13_to_v12,
-        from_policy_v13_to_v14, from_policy_v13_to_v15, from_policy_v13_to_v9,
+        from_policy_v13_to_v14, from_policy_v13_to_v15, from_policy_v13_to_v16,
+        from_policy_v13_to_v9,
     },
     miner, power,
 };
@@ -394,6 +395,15 @@ impl RpcMethod<1> for GetPowerTable {
                     &from_policy_v13_to_v15(&ctx.chain_config().policy)
                 );
             }
+            power::State::V16(s) => {
+                handle_miner_state_v12_on!(
+                    v16,
+                    id_power_worker_mappings,
+                    &ts,
+                    s,
+                    &from_policy_v13_to_v16(&ctx.chain_config().policy)
+                );
+            }
         }
         let mut power_entries = vec![];
         for (id, power, worker) in id_power_worker_mappings {

src/rpc/methods/state.rs

@@ -388,6 +388,24 @@ impl RpcMethod<2> for StateLookupRobustAddress {
                     .context("Robust address not found")?;
                     Ok(robust_addr)
                 }
+                init::State::V16(state) => {
+                    let map = fil_actor_init_state::v16::AddressMap::load(
+                        &store,
+                        &state.address_map,
+                        fil_actors_shared::v16::DEFAULT_HAMT_CONFIG,
+                        "address_map",
+                    )
+                    .context("Failed to load address map")?;
+                    map.for_each(|addr, v| {
+                        if *v == id_addr_decoded {
+                            robust_addr = addr.into();
+                            return Ok(());
+                        }
+                        Ok(())
+                    })
+                    .context("Robust address not found")?;
+                    Ok(robust_addr)
+                }
             }
         } else {
             Ok(Address::default())
@@ -814,6 +832,10 @@ impl RpcMethod<2> for StateMinerAvailableBalance {
         let state = miner::State::load(ctx.store(), actor.code, actor.state)?;
         let actor_balance: TokenAmount = actor.balance.clone().into();
         let (vested, available): (TokenAmount, TokenAmount) = match &state {
+            miner::State::V16(s) => (
+                s.check_vested_funds(ctx.store(), ts.epoch())?.into(),
+                s.get_available_balance(&actor_balance.into())?.into(),
+            ),
             miner::State::V15(s) => (
                 s.check_vested_funds(ctx.store(), ts.epoch())?.into(),
                 s.get_available_balance(&actor_balance.into())?.into(),
@@ -1944,6 +1966,20 @@ impl StateSectorPreCommitInfo {
                     })
                     .context("failed to iterate over precommitted sectors")
             }
+            miner::State::V16(s) => {
+                let precommitted = fil_actor_miner_state::v16::PreCommitMap::load(
+                    store,
+                    &s.pre_committed_sectors,
+                    fil_actor_miner_state::v16::PRECOMMIT_CONFIG,
+                    "precommits",
+                )?;
+                precommitted
+                    .for_each(|_k, v| {
+                        sectors.push(v.info.sector_number);
+                        Ok(())
+                    })
+                    .context("failed to iterate over precommitted sectors")
+            }
         }?;
 
         Ok(sectors)
@@ -2058,6 +2094,20 @@ impl StateSectorPreCommitInfo {
                     })
                     .context("failed to iterate over precommitted sectors")
             }
+            miner::State::V16(s) => {
+                let precommitted = fil_actor_miner_state::v16::PreCommitMap::load(
+                    store,
+                    &s.pre_committed_sectors,
+                    fil_actor_miner_state::v16::PRECOMMIT_CONFIG,
+                    "precommits",
+                )?;
+                precommitted
+                    .for_each(|_k, v| {
+                        infos.push(v.info.clone().into());
+                        Ok(())
+                    })
+                    .context("failed to iterate over precommitted sectors")
+            }
         }?;
 
         Ok(infos)
@@ -2479,6 +2529,18 @@ impl StateGetAllocations {
                         Ok(())
                     })?;
                 }
+                init::State::V16(s) => {
+                    let map = fil_actor_init_state::v16::AddressMap::load(
+                        store,
+                        &s.address_map,
+                        fil_actors_shared::v16::DEFAULT_HAMT_CONFIG,
+                        "address_map",
+                    )?;
+                    map.for_each(|_k, v| {
+                        addresses.insert(Address::new_id(*v));
+                        Ok(())
+                    })?;
+                }
             };
         }