feat(shed): add forest-tool shed f3 check-activation-raw

Author: hanabi1224

Cargo.lock

@@ -78,6 +78,7 @@ 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"] }
+flate2 = "1"
 flume = { workspace = true }
 fs_extra = "1"
 futures = { workspace = true }

Cargo.toml

@@ -12,6 +12,8 @@ FOREST_NODE_PID=$!
 FULLNODE_API_INFO="$(cat admin_token):/ip4/127.0.0.1/tcp/2345/http"
 export FULLNODE_API_INFO
 
+forest_wait_api
+
 # Verify that one of the seed nodes has been connected to
 until $FOREST_CLI_PATH net peers | grep "calib"; do
     sleep 1s;

scripts/tests/calibnet_no_discovery_check.sh

@@ -354,7 +354,10 @@ impl F3PowerTableCommands {
         if instance < manifest.initial_instance + manifest.committee_lookback {
             let epoch = manifest.bootstrap_epoch - manifest.ec.finality;
             let ts = ChainGetTipSetByHeight::call(client, (epoch, None.into())).await?;
-            return Ok((ts.key().clone(), manifest.initial_power_table));
+            return Ok((
+                ts.key().clone(),
+                manifest.initial_power_table.unwrap_or_default(),
+            ));
         }
 
         let previous = F3GetCertificate::call(client, (instance.saturating_sub(1),)).await?;
@@ -377,10 +380,11 @@ fn render_manifest_template(template: &F3Manifest) -> anyhow::Result<String> {
     let mut context = tera::Context::from_serialize(template)?;
     context.insert(
         "initial_power_table_cid",
-        &if template.initial_power_table != Cid::default() {
-            Cow::Owned(template.initial_power_table.to_string())
-        } else {
-            Cow::Borrowed("unknown")
+        &match template.initial_power_table {
+            Some(initial_power_table) if initial_power_table != Cid::default() => {
+                Cow::Owned(initial_power_table.to_string())
+            }
+            _ => Cow::Borrowed("unknown"),
         },
     );
     Ok(TEMPLATES

src/cli/subcommands/f3_cmd.rs

@@ -14,7 +14,6 @@ use crate::cli_shared::{
     chain_path,
     cli::{CliOpts, Config},
 };
-
 use crate::daemon::db_util::{
     import_chain_as_forest_car, load_all_forest_cars, populate_eth_mappings,
 };

src/daemon/mod.rs

@@ -281,7 +281,7 @@ pub struct GasReward {
     pub premium: TokenAmount,
 }
 
-#[derive(PartialEq, Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
+#[derive(PartialEq, Debug, Default, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct EthCallMessage {
     pub from: Option<EthAddress>,

src/rpc/methods/eth/types.rs

@@ -279,7 +279,7 @@ pub struct F3Manifest {
     pub ignore_ec_power: bool,
     #[schemars(with = "String")]
     #[serde(with = "crate::lotus_json")]
-    pub initial_power_table: Cid,
+    pub initial_power_table: Option<Cid>,
     pub committee_lookback: u64,
     #[schemars(with = "u64")]
     #[serde(with = "crate::lotus_json")]

src/rpc/methods/f3/types.rs

@@ -1,6 +1,9 @@
 // Copyright 2019-2025 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
+mod f3;
+use f3::*;
+
 use std::path::PathBuf;
 
 use crate::{
@@ -58,6 +61,9 @@ pub enum ShedCommands {
         #[arg(long)]
         path: ApiPath,
     },
+    /// F3 related commands.
+    #[command(subcommand)]
+    F3(F3Commands),
 }
 
 impl ShedCommands {
@@ -137,8 +143,9 @@ impl ShedCommands {
                     _ => std::cmp::Ordering::Equal,
                 });
 
-                println!("{}", serde_json::to_string_pretty(&openrpc_doc).unwrap());
+                println!("{}", serde_json::to_string_pretty(&openrpc_doc)?);
             }
+            ShedCommands::F3(cmd) => cmd.run(client).await?,
         }
         Ok(())
     }

src/tool/subcommands/shed_cmd.rs

@@ -0,0 +1,111 @@
+// Copyright 2019-2025 ChainSafe Systems
+// SPDX-License-Identifier: Apache-2.0, MIT
+
+use crate::{
+    rpc::{
+        self,
+        eth::types::{EthAddress, EthBytes, EthCallMessage},
+        f3::F3Manifest,
+        state::StateCall,
+        RpcMethodExt,
+    },
+    shim::message::Message,
+};
+use clap::Subcommand;
+use flate2::read::DeflateDecoder;
+use std::{io::Read, str::FromStr as _};
+
+const MAX_PAYLOAD_LEN: usize = 4 << 10;
+
+#[derive(Debug, Subcommand)]
+pub enum F3Commands {
+    CheckActivation {
+        /// Contract address
+        #[arg(long, required = true)]
+        contract: String,
+    },
+    CheckActivationRaw {
+        /// Contract address
+        #[arg(long, required = true)]
+        contract: String,
+    },
+}
+
+impl F3Commands {
+    #[allow(clippy::indexing_slicing)]
+    pub async fn run(self, client: rpc::Client) -> anyhow::Result<()> {
+        match self {
+            Self::CheckActivation { contract: _ } => {
+                unimplemented!("Will be done in a subsequent PR");
+            }
+            Self::CheckActivationRaw { contract } => {
+                let eth_call_message = EthCallMessage {
+                    to: Some(EthAddress::from_str(&contract)?),
+                    data: EthBytes::from_str("0x2587660d")?, // method ID of activationInformation()
+                    ..Default::default()
+                };
+                let filecoin_message = Message::try_from(eth_call_message)?;
+                let api_invoc_result =
+                    StateCall::call(&client, (filecoin_message, None.into())).await?;
+                let Some(message_receipt) = api_invoc_result.msg_rct else {
+                    anyhow::bail!("No message receipt")
+                };
+                anyhow::ensure!(
+                    message_receipt.exit_code().is_success(),
+                    "unsuccessful exit code {}",
+                    message_receipt.exit_code()
+                );
+                let return_data = message_receipt.return_data();
+                let eth_return =
+                    fvm_ipld_encoding::from_slice::<fvm_ipld_encoding::BytesDe>(&return_data)?.0;
+                println!("Raw data: {}", hex::encode(eth_return.as_slice()));
+                // 3*32 because there should be 3 slots minimum
+                anyhow::ensure!(eth_return.len() >= 3 * 32, "no activation information");
+                let mut activation_epoch_bytes: [u8; 8] = [0; 8];
+                activation_epoch_bytes.copy_from_slice(&eth_return[24..32]);
+                let activation_epoch = u64::from_be_bytes(activation_epoch_bytes);
+                for (i, &v) in eth_return[32..63].iter().enumerate() {
+                    anyhow::ensure!(
+                        v == 0,
+                        "wrong value for offset (padding): slot[{i}] = 0x{v:x} != 0x00"
+                    );
+                }
+                anyhow::ensure!(
+                    eth_return[63] == 0x40,
+                    "wrong value for offest : slot[31] = 0x{:x} != 0x40",
+                    eth_return[63]
+                );
+                let mut payload_len_bytes: [u8; 8] = [0; 8];
+                payload_len_bytes.copy_from_slice(&eth_return[88..96]);
+                let payload_len = u64::from_be_bytes(payload_len_bytes) as usize;
+                anyhow::ensure!(
+                    payload_len <= MAX_PAYLOAD_LEN,
+                    "too long declared payload: {payload_len} > {MAX_PAYLOAD_LEN}"
+                );
+                let payload_bytes = &eth_return[96..];
+                anyhow::ensure!(
+                    payload_len <= payload_bytes.len(),
+                    "not enough remaining bytes: {payload_len} > {}",
+                    payload_bytes.len()
+                );
+                anyhow::ensure!(
+                    activation_epoch < u64::MAX && payload_len > 0,
+                    "no active activation"
+                );
+                let compressed_manifest_bytes = &payload_bytes[..payload_len];
+                let mut deflater = DeflateDecoder::new(compressed_manifest_bytes);
+                let mut manifest_bytes = vec![];
+                deflater.read_to_end(&mut manifest_bytes)?;
+                let manifest: F3Manifest = serde_json::from_slice(&manifest_bytes)?;
+                anyhow::ensure!(
+                    manifest.bootstrap_epoch >= 0
+                        && manifest.bootstrap_epoch as u64 == activation_epoch,
+                    "bootstrap epoch does not match: {} != {activation_epoch}",
+                    manifest.bootstrap_epoch
+                );
+                println!("{}", serde_json::to_string_pretty(&manifest)?);
+            }
+        }
+        Ok(())
+    }
+}