fix: storage node pattern

Author: karlem

fendermint/actors/blobs/src/actor.rs

@@ -52,7 +52,33 @@ impl BlobsActor {
         params: InvokeContractParams,
     ) -> Result<InvokeContractReturn, ActorError> {
         let input_data: InputData = params.try_into()?;
-        if sol_blobs::can_handle(&input_data) {
+        if sol_blobs::is_register_node_operator_call(&input_data) {
+            let params = sol_blobs::parse_register_node_operator_input(&input_data)?;
+            let params = fendermint_actor_blobs_shared::operators::RegisterNodeOperatorParams {
+                bls_pubkey: params.bls_pubkey,
+                rpc_url: params.rpc_url,
+            };
+            let _ = Self::register_node_operator(rt, params)?;
+            Ok(InvokeContractReturn {
+                output_data: Vec::new(),
+            })
+        } else if sol_blobs::is_get_operator_info_call(&input_data) {
+            let params = sol_blobs::parse_get_operator_info_input(&input_data)?;
+            let address = rt
+                .resolve_address(&params.address)
+                .map(fvm_shared::address::Address::new_id)
+                .unwrap_or(params.address);
+            let info = Self::get_operator_info(
+                rt,
+                fendermint_actor_blobs_shared::operators::GetOperatorInfoParams { address },
+            )?;
+            let output_data = sol_blobs::encode_get_operator_info_output(info)?;
+            Ok(InvokeContractReturn { output_data })
+        } else if sol_blobs::is_get_active_operators_call(&input_data) {
+            let operators = Self::get_active_operators(rt)?;
+            let output_data = sol_blobs::encode_get_active_operators_output(operators.operators)?;
+            Ok(InvokeContractReturn { output_data })
+        } else if sol_blobs::can_handle(&input_data) {
             let output_data = match sol_blobs::parse_input(&input_data)? {
                 sol_blobs::Calls::addBlob(call) => {
                     let params = call.params(rt)?;

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

@@ -8,6 +8,7 @@ use fendermint_actor_blobs_shared::{
         TrimBlobExpiriesParams,
     },
     bytes::B256,
+    operators::OperatorInfo,
     GetStatsReturn,
 };
 use fil_actors_runtime::{actor_error, runtime::Runtime, ActorError};
@@ -112,6 +113,247 @@ pub fn parse_input(input: &ipc_storage_actor_sdk::evm::InputData) -> Result<Call
         .map_err(|e| actor_error!(illegal_argument, format!("invalid call: {}", e)))
 }
 
+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];
+
+pub struct RegisterNodeOperatorInvokeCall {
+    pub bls_pubkey: Vec<u8>,
+    pub rpc_url: String,
+}
+
+pub struct GetOperatorInfoInvokeCall {
+    pub address: Address,
+}
+
+pub fn is_register_node_operator_call(input: &ipc_storage_actor_sdk::evm::InputData) -> bool {
+    input.selector() == REGISTER_NODE_OPERATOR_SELECTOR
+}
+
+pub fn is_get_operator_info_call(input: &ipc_storage_actor_sdk::evm::InputData) -> bool {
+    input.selector() == GET_OPERATOR_INFO_SELECTOR
+}
+
+pub fn is_get_active_operators_call(input: &ipc_storage_actor_sdk::evm::InputData) -> bool {
+    input.selector() == GET_ACTIVE_OPERATORS_SELECTOR
+}
+
+pub fn parse_register_node_operator_input(
+    input: &ipc_storage_actor_sdk::evm::InputData,
+) -> Result<RegisterNodeOperatorInvokeCall, ActorError> {
+    let calldata = input.calldata();
+    if calldata.len() < 64 {
+        return Err(actor_error!(illegal_argument, "invalid call: input too short"));
+    }
+
+    let bls_offset = decode_offset(calldata, 0)?;
+    let rpc_offset = decode_offset(calldata, 32)?;
+
+    let bls_pubkey = decode_dynamic_bytes(calldata, bls_offset)?;
+    let rpc_bytes = decode_dynamic_bytes(calldata, rpc_offset)?;
+    let rpc_url = String::from_utf8(rpc_bytes)
+        .map_err(|e| actor_error!(illegal_argument, format!("invalid call: bad UTF-8: {}", e)))?;
+
+    Ok(RegisterNodeOperatorInvokeCall {
+        bls_pubkey,
+        rpc_url,
+    })
+}
+
+pub fn parse_get_operator_info_input(
+    input: &ipc_storage_actor_sdk::evm::InputData,
+) -> Result<GetOperatorInfoInvokeCall, ActorError> {
+    let calldata = input.calldata();
+    if calldata.len() < 32 {
+        return Err(actor_error!(illegal_argument, "invalid call: input too short"));
+    }
+    let word = &calldata[0..32];
+    if word[..12].iter().any(|b| *b != 0) {
+        return Err(actor_error!(
+            illegal_argument,
+            "invalid call: malformed address"
+        ));
+    }
+    let address: Address = H160::from_slice(&word[12..32]).into();
+    Ok(GetOperatorInfoInvokeCall { address })
+}
+
+pub fn encode_get_operator_info_output(info: Option<OperatorInfo>) -> Result<Vec<u8>, ActorError> {
+    let (bls_pubkey, rpc_url, active) = if let Some(info) = info {
+        (info.bls_pubkey, info.rpc_url.into_bytes(), info.active)
+    } else {
+        (Vec::new(), Vec::new(), false)
+    };
+
+    let bls_section = encode_dynamic_bytes(&bls_pubkey);
+    let rpc_section = encode_dynamic_bytes(&rpc_url);
+
+    let head_size = 32 * 3;
+    let bls_offset = head_size;
+    let rpc_offset = head_size + bls_section.len();
+
+    let mut output = Vec::with_capacity(head_size + bls_section.len() + rpc_section.len());
+    output.extend_from_slice(&abi_word_from_usize(bls_offset));
+    output.extend_from_slice(&abi_word_from_usize(rpc_offset));
+    output.extend_from_slice(&abi_word_from_bool(active));
+    output.extend_from_slice(&bls_section);
+    output.extend_from_slice(&rpc_section);
+    Ok(output)
+}
+
+pub fn encode_get_active_operators_output(operators: Vec<Address>) -> Result<Vec<u8>, ActorError> {
+    let mut operators_section = Vec::with_capacity(32 + operators.len() * 32);
+    operators_section.extend_from_slice(&abi_word_from_usize(operators.len()));
+    for operator in operators {
+        let h160 = H160::try_from(operator).map_err(|e| {
+            actor_error!(
+                illegal_argument,
+                format!("failed to encode operator address: {}", e)
+            )
+        })?;
+        operators_section.extend_from_slice(&abi_word_from_address(h160));
+    }
+
+    let mut output = Vec::with_capacity(32 + operators_section.len());
+    output.extend_from_slice(&abi_word_from_usize(32));
+    output.extend_from_slice(&operators_section);
+    Ok(output)
+}
+
+fn decode_offset(calldata: &[u8], at: usize) -> Result<usize, ActorError> {
+    let end = at + 32;
+    if end > calldata.len() {
+        return Err(actor_error!(illegal_argument, "invalid call: malformed offset"));
+    }
+    let word = &calldata[at..end];
+    if word[..24].iter().any(|b| *b != 0) {
+        return Err(actor_error!(
+            illegal_argument,
+            "invalid call: offset too large"
+        ));
+    }
+    let mut n = [0u8; 8];
+    n.copy_from_slice(&word[24..32]);
+    Ok(u64::from_be_bytes(n) as usize)
+}
+
+fn decode_dynamic_bytes(calldata: &[u8], offset: usize) -> Result<Vec<u8>, ActorError> {
+    if offset + 32 > calldata.len() {
+        return Err(actor_error!(
+            illegal_argument,
+            "invalid call: dynamic offset out of bounds"
+        ));
+    }
+
+    let len = decode_offset(calldata, offset)?;
+    let start = offset + 32;
+    let end = start
+        .checked_add(len)
+        .ok_or_else(|| actor_error!(illegal_argument, "invalid call: overflow"))?;
+
+    if end > calldata.len() {
+        return Err(actor_error!(
+            illegal_argument,
+            "invalid call: dynamic value out of bounds"
+        ));
+    }
+
+    Ok(calldata[start..end].to_vec())
+}
+
+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());
+    word
+}
+
+fn abi_word_from_bool(value: bool) -> [u8; 32] {
+    let mut word = [0u8; 32];
+    word[31] = u8::from(value);
+    word
+}
+
+fn abi_word_from_address(value: H160) -> [u8; 32] {
+    let mut word = [0u8; 32];
+    word[12..32].copy_from_slice(&value.to_fixed_bytes());
+    word
+}
+
+fn encode_dynamic_bytes(value: &[u8]) -> Vec<u8> {
+    let mut out = Vec::with_capacity(32 + padded_32_len(value.len()));
+    out.extend_from_slice(&abi_word_from_usize(value.len()));
+    out.extend_from_slice(value);
+    let padding = padded_32_len(value.len()) - value.len();
+    out.extend(std::iter::repeat(0u8).take(padding));
+    out
+}
+
+fn padded_32_len(size: usize) -> usize {
+    if size == 0 { 0 } else { size.div_ceil(32) * 32 }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn address_word(bytes20: [u8; 20]) -> [u8; 32] {
+        let mut word = [0u8; 32];
+        word[12..32].copy_from_slice(&bytes20);
+        word
+    }
+
+    #[test]
+    fn parses_get_operator_info_input_address() {
+        let addr = [0x11u8; 20];
+        let mut input = Vec::new();
+        input.extend_from_slice(&GET_OPERATOR_INFO_SELECTOR);
+        input.extend_from_slice(&address_word(addr));
+        let input =
+            ipc_storage_actor_sdk::evm::InputData::try_from(ipc_storage_actor_sdk::evm::InvokeContractParams {
+                input_data: input,
+            })
+            .expect("valid input");
+
+        let parsed = parse_get_operator_info_input(&input).expect("parse succeeds");
+        let expected = Address::new_delegated(10, &addr).expect("delegated");
+        assert_eq!(parsed.address, expected);
+    }
+
+    #[test]
+    fn encodes_get_active_operators_output_as_address_array() {
+        let id = Address::new_id(66);
+        let delegated = Address::new_delegated(10, &[0x22; 20]).expect("delegated");
+
+        let encoded = encode_get_active_operators_output(vec![id, delegated]).expect("encode");
+
+        assert_eq!(&encoded[0..32], &abi_word_from_usize(32));
+        assert_eq!(&encoded[32..64], &abi_word_from_usize(2));
+
+        let id_h160 = H160::try_from(id).expect("id to h160");
+        let delegated_h160 = H160::try_from(delegated).expect("delegated to h160");
+        assert_eq!(&encoded[64..96], &abi_word_from_address(id_h160));
+        assert_eq!(&encoded[96..128], &abi_word_from_address(delegated_h160));
+    }
+
+    #[test]
+    fn encodes_get_operator_info_output_tuple() {
+        let info = OperatorInfo {
+            bls_pubkey: vec![1, 2, 3, 4],
+            rpc_url: "http://127.0.0.1:8081".to_string(),
+            active: true,
+        };
+        let encoded = encode_get_operator_info_output(Some(info)).expect("encode");
+
+        assert_eq!(&encoded[0..32], &abi_word_from_usize(96));
+        let bls_section_len = 32 + 32; // len + padded data for 4 bytes
+        assert_eq!(
+            &encoded[32..64],
+            &abi_word_from_usize(96 + bls_section_len)
+        );
+        assert_eq!(&encoded[64..96], &abi_word_from_bool(true));
+    }
+}
+
 fn blob_status_as_solidity_enum(blob_status: BlobStatus) -> u8 {
     match blob_status {
         BlobStatus::Added => 0,

ipc-storage/README.md

@@ -51,6 +51,11 @@ export SECRET_KEY_FILE=./test-network/keys/alice.sk
 
 ```
 
+Notes:
+- `register-operator` now supports delegated (`t410...`) operator keys through the blobs actor `InvokeContract` facade path.
+- Operator query methods are also available through the same facade path: `getOperatorInfo(address)` and `getActiveOperators()`.
+- Storage node and gateway use delegated (`t410...`) sender path for on-chain interactions; fund delegated operator address before running.
+
 ## 3. Launch ipc-dropbox
 Launch `ipc-dropbox` in `ipc-storage/ipc-dropbox` with `npm run dev`.
 

ipc-storage/ipc-decentralized-storage/src/bin/gateway.rs

@@ -3,12 +3,13 @@
 
 //! CLI for running the blob gateway with objects API
 
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result};
 use bls_signatures::{PrivateKey as BlsPrivateKey, Serialize as BlsSerialize};
 use clap::Parser;
 use fendermint_rpc::message::SignedMessageFactory;
 use fendermint_rpc::FendermintClient;
 use fendermint_rpc::QueryClient;
+use fendermint_vm_actor_interface::eam::EthAddress as FvmEthAddress;
 use fendermint_vm_message::query::FvmQueryHeight;
 use fvm_shared::address::{set_current_network, Address, Network};
 use fvm_shared::chainid::ChainID;
@@ -79,16 +80,16 @@ struct Args {
     iroh_v6_addr: Option<SocketAddrV6>,
 }
 
-/// Get the next sequence number (nonce) of an account.
-async fn get_sequence(client: &impl QueryClient, addr: &Address) -> Result<u64> {
+/// Get the next sequence number (nonce) of an account if it exists.
+async fn get_sequence_opt(client: &impl QueryClient, addr: &Address) -> Result<Option<u64>> {
     let state = client
         .actor_state(addr, FvmQueryHeight::default())
         .await
         .context("failed to get actor state")?;
 
     match state.value {
-        Some((_id, state)) => Ok(state.sequence),
-        None => Err(anyhow!("cannot find actor {addr}")),
+        Some((_id, state)) => Ok(Some(state.sequence)),
+        None => Ok(None),
     }
 }
 
@@ -125,10 +126,13 @@ async fn main() -> Result<()> {
         .context("failed to read secret key")?;
 
     let pk = sk.public_key();
-    // Use f1 address (secp256k1) for signing native FVM actor transactions
-    let from_addr =
-        Address::new_secp256k1(&pk.serialize()).context("failed to create f1 address")?;
-    tracing::info!("Gateway sender address: {}", from_addr);
+    let from_f1 = Address::new_secp256k1(&pk.serialize()).context("failed to create f1 address")?;
+    let from_eth = FvmEthAddress::new_secp256k1(&pk.serialize())
+        .context("failed to derive delegated address from secret key")?;
+    let from_f410 =
+        Address::new_delegated(10, &from_eth.0).context("failed to create f410 address")?;
+    tracing::info!("Gateway sender f1 address: {}", from_f1);
+    tracing::info!("Gateway sender f410 address: {}", from_f410);
 
     // Parse or generate BLS private key if provided
     let _bls_private_key = if let Some(key_file) = &args.bls_key_file {
@@ -214,11 +218,6 @@ async fn main() -> Result<()> {
     let client = FendermintClient::new_http(args.rpc_url, None)
         .context("failed to create Fendermint client")?;
 
-    // Query the account nonce from the state
-    let sequence = get_sequence(&client, &from_addr)
-        .await
-        .context("failed to get account sequence")?;
-
     // Query the chain ID
     let chain_id = client
         .state_params(FvmQueryHeight::default())
@@ -228,6 +227,20 @@ async fn main() -> Result<()> {
         .chain_id;
 
     tracing::info!("Chain ID: {}", chain_id);
+
+    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 {
+        anyhow::bail!(
+            "delegated sender {} not found on-chain; cross-fund this delegated address and retry (native f1 {} is intentionally not used)",
+            from_f410, from_f1
+        );
+    };
+    tracing::info!("Gateway sender address: {}", from_addr);
     tracing::info!("Account sequence: {}", sequence);
 
     // Create signed message factory