feat: make storage node work e2e with cli

Author: karlem

Cargo.lock

@@ -103,6 +103,12 @@ impl BlobsActor {
             Ok(InvokeContractReturn {
                 output_data: Vec::new(),
             })
+        } else if sol_blobs::is_finalize_blob_call(&input_data) {
+            let params = sol_blobs::parse_finalize_blob_input(&input_data, rt)?;
+            Self::finalize_blob(rt, params)?;
+            Ok(InvokeContractReturn {
+                output_data: Vec::new(),
+            })
         } else if sol_blobs::can_handle(&input_data) {
             let output_data = match sol_blobs::parse_input(&input_data)? {
                 sol_blobs::Calls::addBlob(call) => {

fendermint/actors/blobs/src/actor.rs

@@ -4,8 +4,8 @@
 
 use fendermint_actor_blobs_shared::{
     blobs::{
-        AddBlobParams, Blob, BlobStatus, DeleteBlobParams, GetBlobParams, OverwriteBlobParams,
-        TrimBlobExpiriesParams,
+        AddBlobParams, Blob, BlobStatus, DeleteBlobParams, FinalizeBlobParams, GetBlobParams,
+        OverwriteBlobParams, SubscriptionId, TrimBlobExpiriesParams,
     },
     bytes::B256,
     execution::{
@@ -120,6 +120,8 @@ pub fn parse_input(input: &ipc_storage_actor_sdk::evm::InputData) -> Result<Call
 pub const REGISTER_NODE_OPERATOR_SELECTOR: [u8; 4] = [0x71, 0x3b, 0x10, 0xcf];
 pub const GET_OPERATOR_INFO_SELECTOR: [u8; 4] = [0x27, 0xd9, 0xab, 0x5d];
 pub const GET_ACTIVE_OPERATORS_SELECTOR: [u8; 4] = [0x64, 0xbd, 0xc6, 0x7e];
+/// keccak256("finalizeBlob(bytes32,address,bytes32,uint64,string,uint8,bytes,uint128)")
+pub const FINALIZE_BLOB_SELECTOR: [u8; 4] = [0xf6, 0x94, 0x17, 0x21];
 
 pub struct RegisterNodeOperatorInvokeCall {
     pub bls_pubkey: Vec<u8>,
@@ -183,6 +185,10 @@ pub fn is_fail_job_call(input: &ipc_storage_actor_sdk::evm::InputData) -> bool {
     input.selector() == FAIL_JOB_SELECTOR
 }
 
+pub fn is_finalize_blob_call(input: &ipc_storage_actor_sdk::evm::InputData) -> bool {
+    input.selector() == FINALIZE_BLOB_SELECTOR
+}
+
 pub fn parse_register_node_operator_input(
     input: &ipc_storage_actor_sdk::evm::InputData,
 ) -> Result<RegisterNodeOperatorInvokeCall, ActorError> {
@@ -309,6 +315,54 @@ pub fn parse_fail_job_input(
     })
 }
 
+/// Parses ABI-encoded calldata for `finalizeBlob(bytes32,address,bytes32,uint64,string,uint8,bytes,uint128)`.
+pub fn parse_finalize_blob_input(
+    input: &ipc_storage_actor_sdk::evm::InputData,
+    rt: &impl Runtime,
+) -> Result<FinalizeBlobParams, ActorError> {
+    let calldata = input.calldata();
+    // 8 head slots: source(32) + subscriber(32) + blobHash(32) + size(32)
+    //              + string_offset(32) + status(32) + bytes_offset(32) + signerBitmap(32)
+    if calldata.len() < 32 * 8 {
+        return Err(actor_error!(
+            illegal_argument,
+            "invalid finalizeBlob call: input too short"
+        ));
+    }
+
+    let source = decode_b256_word(calldata, 0)?;
+    let subscriber_h160 = decode_address_word(calldata, 32)?;
+    let subscriber: Address = subscriber_h160.into();
+    let subscriber = rt
+        .resolve_address(&subscriber)
+        .map(Address::new_id)
+        .unwrap_or(subscriber);
+    let hash = decode_b256_word(calldata, 64)?;
+    let size = decode_u64_word(calldata, 96)?;
+    let subscription_id_str = decode_dynamic_string(calldata, decode_offset(calldata, 128)?)?;
+    let subscription_id: SubscriptionId = subscription_id_str.try_into().map_err(|e| {
+        actor_error!(
+            illegal_argument,
+            format!("invalid finalizeBlob call: bad subscription id: {}", e)
+        )
+    })?;
+    let status_u8 = decode_u8_word(calldata, 160)?;
+    let status = solidity_enum_to_blob_status(status_u8)?;
+    let aggregated_signature = decode_dynamic_bytes(calldata, decode_offset(calldata, 192)?)?;
+    let signer_bitmap = decode_u128_word(calldata, 224)?;
+
+    Ok(FinalizeBlobParams {
+        source,
+        subscriber,
+        hash,
+        size,
+        id: subscription_id,
+        status,
+        aggregated_signature,
+        signer_bitmap,
+    })
+}
+
 impl From<CreateJobInvokeCall> for CreateJobParams {
     fn from(value: CreateJobInvokeCall) -> Self {
         CreateJobParams {
@@ -507,6 +561,69 @@ fn decode_b256_word(calldata: &[u8], at: usize) -> Result<B256, ActorError> {
     Ok(B256(out))
 }
 
+fn decode_address_word(calldata: &[u8], at: usize) -> Result<H160, ActorError> {
+    let end = at + 32;
+    if end > calldata.len() {
+        return Err(actor_error!(
+            illegal_argument,
+            "invalid call: malformed address word"
+        ));
+    }
+    let word = &calldata[at..end];
+    if word[..12].iter().any(|b| *b != 0) {
+        return Err(actor_error!(
+            illegal_argument,
+            "invalid call: malformed address"
+        ));
+    }
+    Ok(H160::from_slice(&word[12..32]))
+}
+
+fn decode_u8_word(calldata: &[u8], at: usize) -> Result<u8, ActorError> {
+    let end = at + 32;
+    if end > calldata.len() {
+        return Err(actor_error!(illegal_argument, "invalid call: malformed word"));
+    }
+    let word = &calldata[at..end];
+    if word[..31].iter().any(|b| *b != 0) {
+        return Err(actor_error!(
+            illegal_argument,
+            "invalid call: uint8 value too large"
+        ));
+    }
+    Ok(word[31])
+}
+
+fn decode_u128_word(calldata: &[u8], at: usize) -> Result<u128, ActorError> {
+    let end = at + 32;
+    if end > calldata.len() {
+        return Err(actor_error!(illegal_argument, "invalid call: malformed word"));
+    }
+    let word = &calldata[at..end];
+    if word[..16].iter().any(|b| *b != 0) {
+        return Err(actor_error!(
+            illegal_argument,
+            "invalid call: uint128 value too large"
+        ));
+    }
+    let mut n = [0u8; 16];
+    n.copy_from_slice(&word[16..32]);
+    Ok(u128::from_be_bytes(n))
+}
+
+fn solidity_enum_to_blob_status(value: u8) -> Result<BlobStatus, ActorError> {
+    match value {
+        0 => Ok(BlobStatus::Added),
+        1 => Ok(BlobStatus::Pending),
+        2 => Ok(BlobStatus::Resolved),
+        3 => Ok(BlobStatus::Failed),
+        _ => Err(actor_error!(
+            illegal_argument,
+            format!("invalid BlobStatus enum value: {}", value)
+        )),
+    }
+}
+
 fn abi_word_from_usize(value: usize) -> [u8; 32] {
     let mut word = [0u8; 32];
     word[24..32].copy_from_slice(&(value as u64).to_be_bytes());

fendermint/actors/blobs/src/sol_facade/blobs.rs

@@ -195,6 +195,11 @@ impl SignedMessageFactory {
         self.inner.address()
     }
 
+    /// Set the sequence to an arbitrary value, e.g. after resyncing from chain state.
+    pub fn set_sequence(&mut self, sequence: u64) {
+        self.inner.set_sequence(sequence);
+    }
+
     /// Transfer tokens to another account.
     pub fn transfer(
         &mut self,

fendermint/rpc/src/message.rs

@@ -3,7 +3,7 @@
 
 use crate::finality::{ensure_sequential, ParentViewPayload};
 use crate::{BlockHash, BlockHeight, Config, Error, IPCParentFinality, SequentialKeyCache};
-use async_stm::{abort, atomically, Stm, StmResult, TVar};
+use async_stm::{abort, Stm, StmResult, TVar};
 use ipc_api::cross::IpcEnvelope;
 use ipc_api::staking::PowerChangeRequest;
 use std::cmp::min;

fendermint/vm/topdown/src/finality/null.rs

@@ -4,28 +4,28 @@
 
 # deploy:
 #   url: "https://api.calibration.node.glif.io/rpc/v1"
-#   from: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266"
+#   from: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
 #   chain-id: 314159
 
 node-topdown-mode: legacy
 
 create:
   parent: /r314159
   chain-id: 314159
-  from: 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+  from: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
   min-validator-stake: 1.0
   min-validators: 1
   bottomup-check-period: 50
   permission-mode: federated
   supply-source-kind: native
   min-cross-msg-fee: 0.1
-  genesis-subnet-ipc-contracts-owner: 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+  genesis-subnet-ipc-contracts-owner: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
   parent-filecoin-rpc: "https://api.calibration.node.glif.io/rpc/v1"
 
 activate:
   mode: federated
   validator-pubkeys:
-    - 0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5
+    - 0x04d64f81dcff5f31e67263e3d2df35b0a412bb11935ae6b897018a59bf5d6f9e99ad02cbedd2bfcfbd2a56f02f6812c9f978536496e972fe2fbbf96e8743fb28dc
   validator-power:
     - 1
 

init-sub.yaml

@@ -29,7 +29,8 @@ urlencoding.workspace = true
 blake3.workspace = true
 
 # HTTP client dependencies
-reqwest = { version = "0.11", features = ["json"] }
+reqwest = { version = "0.11", features = ["json", "multipart"] }
+tempfile = "3.8"
 
 # CLI dependencies
 clap = { workspace = true, features = ["derive"] }

ipc-storage/ipc-decentralized-storage/Cargo.toml

@@ -101,6 +101,11 @@ async fn main() -> Result<()> {
         .with(tracing_subscriber::fmt::layer())
         .init();
 
+    tracing::info!(
+        "gateway v{} (build 2026-04-01-fevm-facade)",
+        env!("CARGO_PKG_VERSION"),
+    );
+
     let args = Args::parse();
 
     // Set the network for address display (f for mainnet, t for testnet)
@@ -228,15 +233,27 @@ async fn main() -> Result<()> {
 
     tracing::info!("Chain ID: {}", chain_id);
 
+    // Prefer delegated f410 sender: FinalizeBlob now goes through the EVM facade
+    // (InvokeContract with ABI-encoded calldata) so it works with both f1 and f410.
     let (from_addr, sequence) = if let Some(sequence) = get_sequence_opt(&client, &from_f410)
         .await
         .context("failed to get delegated account sequence")?
     {
         tracing::info!("Using delegated sender (f410) for gateway transactions");
         (from_f410, sequence)
+    } else if let Some(sequence) = get_sequence_opt(&client, &from_f1)
+        .await
+        .context("failed to get native account sequence")?
+    {
+        tracing::info!(
+            "Delegated f410 sender {} is not on-chain; falling back to native f1 sender",
+            from_f410
+        );
+        (from_f1, sequence)
     } else {
         anyhow::bail!(
-            "delegated sender {} not found on-chain; cross-fund this delegated address and retry (native f1 {} is intentionally not used)",
+            "neither delegated sender {} nor native sender {} found on-chain; \
+             fund the delegated (f410) address for gateway transaction signing",
             from_f410, from_f1
         );
     };