feat(shc-common): feature gate parachain dependencies (#581)

* feat(shc-common): feature gate parachain dependencies

Add `parachain` feature to shc-common crate to allow building without
parachain-specific dependencies for solochain deployments.

Changes:
- Add optional `parachain` feature (disabled by default) that controls:
  - cumulus-client-service
  - cumulus-primitives-core
  - cumulus-primitives-storage-weight-reclaim

- Feature gate HostFunctions type:
  - With `parachain`: uses ParachainHostFunctions
  - Without `parachain`: uses SubstrateHostFunctions (solochain mode)

- Rename types for clarity:
  - ParachainExecutor → StorageHubExecutor
  - ParachainClient → StorageHubClient
  - Keep deprecated aliases for backwards compatibility

- Define BlockNumber locally in shp-opaque as u32, removing
  parachains-common dependency

Dependency reduction (shc-common --no-default-features --features std):
- Dependency tree: 5,816 → 3,243 lines (44% fewer)
- Cumulus crates: 44 → 0 (100% removed)
- cumulus-relay-chain-minimal-node: removed

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

* fix: 🩹 Merge imports

* fix: 🚨 Fix compiler issues after merge

---------

Co-authored-by: Claude <[email protected]>
Co-authored-by: Facundo Farall <[email protected]>

Author: 3 people

Cargo.lock

@@ -35,7 +35,7 @@ use shc_blockchain_service_db::{leadership::LeadershipClient, store::PendingTxSt
 use shc_common::{
     blockchain_utils::{convert_raw_multiaddresses_to_multiaddr, get_events_at_block},
     typed_store::{CFDequeAPI, ProvidesTypedDbSingleAccess},
-    types::{AccountId, BlockNumber, OpaqueBlock, ParachainClient, TickNumber},
+    types::{AccountId, BlockNumber, OpaqueBlock, StorageHubClient, TickNumber},
 };
 use shc_forest_manager::traits::ForestStorageHandler;
 
@@ -56,7 +56,7 @@ pub(crate) const LOG_TARGET: &str = "blockchain-service";
 /// The BlockchainService actor.
 ///
 /// This actor is responsible for sending extrinsics to the runtime and handling block import notifications.
-/// For such purposes, it uses the [`ParachainClient<RuntimeApi>`] to interact with the runtime, the [`RpcHandlers`] to send
+/// For such purposes, it uses the [`StorageHubClient<RuntimeApi>`] to interact with the runtime, the [`RpcHandlers`] to send
 /// extrinsics, and the [`Keystore`] to sign the extrinsics.
 pub struct BlockchainService<FSH, Runtime>
 where
@@ -68,8 +68,8 @@ where
     /// The event bus provider.
     pub(crate) event_bus_provider: BlockchainServiceEventBusProvider<Runtime>,
     /// The parachain client. Used to interact with the runtime.
-    /// TODO: Consider not using `ParachainClient` here.
-    pub(crate) client: Arc<ParachainClient<Runtime::RuntimeApi>>,
+    /// TODO: Consider not using `StorageHubClient` here.
+    pub(crate) client: Arc<StorageHubClient<Runtime::RuntimeApi>>,
     /// The keystore. Used to sign extrinsics.
     pub(crate) keystore: KeystorePtr,
     /// The RPC handlers. Used to send extrinsics.
@@ -1355,7 +1355,7 @@ where
     /// Create a new [`BlockchainService`].
     pub fn new(
         config: BlockchainServiceConfig<Runtime>,
-        client: Arc<ParachainClient<Runtime::RuntimeApi>>,
+        client: Arc<StorageHubClient<Runtime::RuntimeApi>>,
         keystore: KeystorePtr,
         rpc_handlers: Arc<RpcHandlers>,
         forest_storage_handler: FSH,

client/blockchain-service/src/handler.rs

@@ -19,14 +19,14 @@ use sp_keystore::KeystorePtr;
 
 use capacity_manager::{CapacityConfig, CapacityRequestQueue};
 use shc_actors_framework::actor::{ActorHandle, ActorSpawner, TaskSpawner};
-use shc_common::types::ParachainClient;
+use shc_common::types::StorageHubClient;
 
 pub use self::handler::BlockchainService;
 
 pub async fn spawn_blockchain_service<FSH, Runtime>(
     task_spawner: &TaskSpawner,
     config: BlockchainServiceConfig<Runtime>,
-    client: Arc<ParachainClient<Runtime::RuntimeApi>>,
+    client: Arc<StorageHubClient<Runtime::RuntimeApi>>,
     keystore: KeystorePtr,
     rpc_handlers: Arc<RpcHandlers>,
     forest_storage_handler: FSH,

client/blockchain-service/src/lib.rs

@@ -27,7 +27,7 @@ use shc_common::{
     traits::{ExtensionOperations, KeyTypeOperations, StorageEnableRuntime},
     types::{
         AccountId, BlockNumber, FileKey, Fingerprint, ForestRoot, MinimalExtension, OpaqueBlock,
-        ParachainClient, ProofsDealerProviderId, StorageEnableEvents, StorageProviderId,
+        ProofsDealerProviderId, StorageEnableEvents, StorageHubClient, StorageProviderId,
         TrieAddMutation, TrieMutation, TrieRemoveMutation, BCSV_KEY_TYPE,
     },
 };
@@ -725,7 +725,7 @@ where
     /// Construct an extrinsic that can be applied to the runtime using a generic signature type.
     pub fn construct_extrinsic(
         &self,
-        client: Arc<ParachainClient<Runtime::RuntimeApi>>,
+        client: Arc<StorageHubClient<Runtime::RuntimeApi>>,
         function: impl Into<Runtime::Call>,
         nonce: u32,
         tip: u128,

client/blockchain-service/src/utils.rs

@@ -56,10 +56,10 @@ k256 = { workspace = true, features = ["ecdsa", "arithmetic"] }
 # Polkadot
 polkadot-primitives = { workspace = true }
 
-# Cumulus
-cumulus-client-service = { workspace = true }
-cumulus-primitives-core = { workspace = true }
-cumulus-primitives-storage-weight-reclaim = { workspace = true }
+# Cumulus (optional, for parachain support)
+cumulus-client-service = { workspace = true, optional = true }
+cumulus-primitives-core = { workspace = true, optional = true }
+cumulus-primitives-storage-weight-reclaim = { workspace = true, optional = true }
 
 # Frontier
 fp-account = { workspace = true }
@@ -91,6 +91,11 @@ tempfile = "3.8"
 
 [features]
 default = ["std"]
+parachain = [
+	"cumulus-client-service",
+	"cumulus-primitives-core",
+	"cumulus-primitives-storage-weight-reclaim",
+]
 std = [
 	"codec/std",
 	"frame-benchmarking/std",
@@ -112,8 +117,8 @@ std = [
 	"sp-std/std",
 	"trie-db/std",
 	"polkadot-primitives/std",
-	"cumulus-primitives-core/std",
-	"cumulus-primitives-storage-weight-reclaim/std",
+	"cumulus-primitives-core?/std",
+	"cumulus-primitives-storage-weight-reclaim?/std",
 	"shp-constants/std",
 	"shp-file-key-verifier/std",
 	"shp-file-metadata/std",

client/common/Cargo.toml

@@ -14,7 +14,7 @@ use sp_core::{H256, U256};
 use crate::{
     traits::{KeyTypeOperations, StorageEnableRuntime},
     types::{
-        Multiaddresses, ParachainClient, StorageHubEventsVec, StorageProviderId, BCSV_KEY_TYPE,
+        Multiaddresses, StorageHubClient, StorageHubEventsVec, StorageProviderId, BCSV_KEY_TYPE,
     },
 };
 
@@ -42,7 +42,7 @@ pub enum EventsRetrievalError {
 
 /// Get the events storage element for a given block.
 pub fn get_events_at_block<Runtime: StorageEnableRuntime>(
-    client: &Arc<ParachainClient<Runtime::RuntimeApi>>,
+    client: &Arc<StorageHubClient<Runtime::RuntimeApi>>,
     block_hash: &H256,
 ) -> Result<StorageHubEventsVec<Runtime>, EventsRetrievalError> {
     // Get the events storage.
@@ -67,7 +67,7 @@ pub fn get_events_at_block<Runtime: StorageEnableRuntime>(
 /// - `Ok(None)` if the block hash doesn't exist (may have been pruned)
 /// - `Err(...)` if there's an error accessing storage
 pub fn get_ethereum_block_hash<RuntimeApi>(
-    client: &Arc<ParachainClient<RuntimeApi>>,
+    client: &Arc<StorageHubClient<RuntimeApi>>,
     block_hash: &H256,
     block_number: u32,
 ) -> Result<Option<H256>, sp_blockchain::Error> {
@@ -144,7 +144,7 @@ pub enum GetProviderIdError {
 /// - `Err(GetProviderIdError::MultipleProviderIds)` if multiple Provider IDs are found
 /// - `Err(GetProviderIdError::RuntimeApiError)` if there's an error calling the runtime API
 pub fn get_provider_id_from_keystore<Runtime>(
-    client: &Arc<ParachainClient<Runtime::RuntimeApi>>,
+    client: &Arc<StorageHubClient<Runtime::RuntimeApi>>,
     keystore: &sp_keystore::KeystorePtr,
     block_hash: &H256,
 ) -> Result<Option<StorageProviderId<Runtime>>, GetProviderIdError>

client/common/src/blockchain_utils.rs

@@ -48,7 +48,7 @@ use crate::types::*;
 ///
 /// ## In Function Signatures
 /// ```ignore
-/// fn spawn_blockchain_service<RuntimeApi>(client: Arc<ParachainClient<RuntimeApi>>)
+/// fn spawn_blockchain_service<RuntimeApi>(client: Arc<StorageHubClient<RuntimeApi>>)
 /// where
 ///     RuntimeApi::RuntimeApi: StorageEnableApiCollection,
 /// {
@@ -181,7 +181,7 @@ where
 }
 
 pub trait StorageEnableRuntimeApi:
-    ConstructRuntimeApi<Block, TFullClient<Block, Self, ParachainExecutor>>
+    ConstructRuntimeApi<Block, TFullClient<Block, Self, StorageHubExecutor>>
     + Sized
     + Send
     + Sync
@@ -190,7 +190,7 @@ pub trait StorageEnableRuntimeApi:
 }
 
 impl<T> StorageEnableRuntimeApi for T where
-    T: ConstructRuntimeApi<Block, TFullClient<Block, Self, ParachainExecutor>>
+    T: ConstructRuntimeApi<Block, TFullClient<Block, Self, StorageHubExecutor>>
         + Sized
         + Send
         + Sync

client/common/src/traits.rs

@@ -121,35 +121,41 @@ pub type StorageHubEventsVec<Runtime> = Vec<
     >,
 >;
 
-#[cfg(not(feature = "runtime-benchmarks"))]
+// Parachain host functions - only available when the `parachain` feature is enabled.
+#[cfg(all(feature = "parachain", not(feature = "runtime-benchmarks")))]
 type HostFunctions = cumulus_client_service::ParachainHostFunctions;
 
-#[cfg(feature = "runtime-benchmarks")]
+#[cfg(all(feature = "parachain", feature = "runtime-benchmarks"))]
 type HostFunctions = (
     cumulus_client_service::ParachainHostFunctions,
     frame_benchmarking::benchmarking::HostFunctions,
 );
 
-/// The wasm executor used by the StorageHub client, which has the set of host functions
-/// that are available in a regular Polkadot Parachain.
+// Solochain host functions - used when the `parachain` feature is disabled.
+#[cfg(all(not(feature = "parachain"), not(feature = "runtime-benchmarks")))]
+type HostFunctions = sp_io::SubstrateHostFunctions;
+
+#[cfg(all(not(feature = "parachain"), feature = "runtime-benchmarks"))]
+type HostFunctions = (
+    sp_io::SubstrateHostFunctions,
+    frame_benchmarking::benchmarking::HostFunctions,
+);
+
+/// The wasm executor used by the StorageHub client.
 ///
-/// The fact that we're using a `ParachainExecutor` is only because we're using the
-/// set of host functions that are available in a regular Polkadot Parachain.
-/// If this client would require a different set of host functions, we would need to
-/// use a different executor, with a different set of host functions.
-pub type ParachainExecutor = WasmExecutor<HostFunctions>;
+/// When the `parachain` feature is enabled, this executor uses the set of host functions
+/// that are available in a regular Polkadot Parachain (`ParachainHostFunctions`).
+/// When the `parachain` feature is disabled (solochain mode), it uses the standard
+/// Substrate host functions (`SubstrateHostFunctions`).
+pub type StorageHubExecutor = WasmExecutor<HostFunctions>;
 
-/// The full client used by the StorageHub client, which uses the [`ParachainExecutor`]
+/// The full client used by the StorageHub client, which uses the [`StorageHubExecutor`]
 /// as the wasm executor.
 ///
 /// It is abstracted over the set of runtime APIs, defined later by a `Runtime` type that
 /// should implement the [`StorageEnableRuntime`](crate::traits::StorageEnableRuntime) trait.
-///
-/// The name `ParachainClient` is a bit misleading, as it is not necessarily a client for a
-/// parachain. But it is called this way because it uses the `ParachainExecutor` which is
-/// a [WasmExecutor] with the [`HostFunctions`] that are available in a regular Polkadot Parachain.
-pub type ParachainClient<RuntimeApi> =
-    TFullClient<shp_opaque::Block, RuntimeApi, ParachainExecutor>;
+pub type StorageHubClient<RuntimeApi> =
+    TFullClient<shp_opaque::Block, RuntimeApi, StorageHubExecutor>;
 
 /// The type of key used for [`BlockchainService`]` operations.
 pub const BCSV_KEY_TYPE: KeyTypeId = KeyTypeId(*b"bcsv");

client/common/src/types.rs

@@ -17,7 +17,7 @@ use shc_actors_framework::actor::{Actor, ActorEventLoop};
 use shc_common::{
     blockchain_utils::get_events_at_block,
     traits::StorageEnableRuntime,
-    types::{BlockNumber, OpaqueBlock, ParachainClient, StorageEnableEvents},
+    types::{BlockNumber, OpaqueBlock, StorageEnableEvents, StorageHubClient},
 };
 use shc_indexer_db::models::FileDeletionType;
 use shp_types::Hash;
@@ -36,7 +36,7 @@ pub(crate) const LOG_TARGET: &str = "fisherman-service";
 /// to the StorageHub protocol to permissionlessly mutate (delete the file key) the merkle forest on chain.
 pub struct FishermanService<Runtime: StorageEnableRuntime> {
     /// Substrate client for blockchain interaction
-    client: Arc<ParachainClient<Runtime::RuntimeApi>>,
+    client: Arc<StorageHubClient<Runtime::RuntimeApi>>,
     /// Event bus provider for emitting fisherman events
     event_bus_provider: FishermanServiceEventBusProvider,
     /// Semaphore to prevent overlapping batch processing cycles (size 1)
@@ -76,7 +76,7 @@ pub enum FileKeyOperation {
 impl<Runtime: StorageEnableRuntime> FishermanService<Runtime> {
     /// Create a new FishermanService instance
     pub fn new(
-        client: Arc<ParachainClient<Runtime::RuntimeApi>>,
+        client: Arc<StorageHubClient<Runtime::RuntimeApi>>,
         batch_interval_seconds: u64,
         batch_deletion_limit: u64,
     ) -> Self {

client/fisherman-service/src/handler.rs

@@ -17,8 +17,7 @@ pub mod handler;
 use std::sync::Arc;
 
 use shc_actors_framework::actor::{ActorHandle, ActorSpawner, TaskSpawner};
-use shc_common::traits::StorageEnableRuntime;
-use shc_common::types::ParachainClient;
+use shc_common::{traits::StorageEnableRuntime, types::StorageHubClient};
 
 pub use self::commands::{
     FishermanServiceCommand, FishermanServiceCommandInterface, FishermanServiceError,
@@ -32,7 +31,7 @@ pub use events::{BatchFileDeletions, FileDeletionTarget, FishermanServiceEventBu
 /// the StorageHub network for file deletion requests and construct proofs of inclusion to delete file keys from Bucket and BSP forests.
 pub async fn spawn_fisherman_service<Runtime: StorageEnableRuntime>(
     task_spawner: &TaskSpawner,
-    client: Arc<ParachainClient<Runtime::RuntimeApi>>,
+    client: Arc<StorageHubClient<Runtime::RuntimeApi>>,
     batch_interval_seconds: u64,
     batch_deletion_limit: u64,
 ) -> ActorHandle<FishermanService<Runtime>> {