refactor: ditch subxt, import runtime

Author: Karrq

Cargo.lock

@@ -56,6 +56,7 @@ axum-test = "18"
 base64 = "0.21"
 bigdecimal = { version = "0.4.5", features = ["serde"] }
 bincode = "1.3.3"
+cfg-if = { version = "1.0.4" }
 clap = { version = "4.5.3", features = ["derive", "env"] }
 chrono = "0.4"
 codec = { package = "parity-scale-codec", version = "3.0.0", features = [

Cargo.toml

@@ -13,10 +13,13 @@ axum-extra = { workspace = true }
 axum-jwt = { workspace = true }
 base64 = { workspace = true }
 bigdecimal = { workspace = true }
+cfg-if = { workspace = true }
 chrono = { workspace = true, features = ["serde"] }
+codec = { workspace = true }
 diesel = { workspace = true }
 diesel-async = { workspace = true }
 futures = { workspace = true }
+frame-support = { workspace = true }
 headers = { workspace = true }
 hex = { workspace = true }
 hex-literal = { workspace = true }
@@ -30,7 +33,6 @@ rustls-pemfile = { workspace = true }
 rustls-platform-verifier = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-subxt = { workspace = true, features = ["native", "jsonrpsee"] }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
 tokio-stream = { workspace = true }
@@ -40,15 +42,14 @@ tower-http = { workspace = true }
 tracing = { workspace = true }
 tracing-bunyan-formatter = { workspace = true }
 tracing-subscriber = { workspace = true }
+trie-db = { workspace = true }
 tokio-postgres = { workspace = true }
 tokio-postgres-rustls = { workspace = true }
 uuid = { version = "1.18", features = ["v7"] }
 
 # Workspace dependencies
-codec = { workspace = true }
 sc-network = { workspace = true }
 sc-network-types = { workspace = true }
-# sh-solochain-evm-runtime = { workspace = true, features = ["std"] }
 shc-common = { workspace = true, default-features = true }
 shc-file-manager = { workspace = true }
 shc-indexer-db = { workspace = true, default-features = true }
@@ -59,8 +60,10 @@ shp-types = { workspace = true }
 sp-core = { workspace = true }
 sp-runtime = { workspace = true }
 sp-trie = { workspace = true }
-# pallet-storage-providers = { workspace = true, features = ["std"] }
-trie-db = { workspace = true }
+pallet-storage-providers = { workspace = true, features = ["std"] }
+
+# Optional deps
+sh-solochain-evm-runtime = { workspace = true, features = ["std"], optional = true }
 
 [dev-dependencies]
 alloy-signer = "0.8"
@@ -72,5 +75,8 @@ testcontainers = "0.24"
 testcontainers-modules = { version = "0.12", features = ["postgres"] }
 
 [features]
-default = []
-mocks = []
+default = ["solochain"]
+mocks = ["solochain"]
+
+# Runtime selection
+solochain = ["dep:sh-solochain-evm-runtime"]

backend/lib/Cargo.toml

@@ -1,25 +1,18 @@
 //! StorageHub RPC client implementation
 
-use std::{future::Future, sync::Arc};
+use std::sync::Arc;
 
 use bigdecimal::BigDecimal;
+use codec::Decode;
 use jsonrpsee::core::traits::ToRpcParams;
 use serde::de::DeserializeOwned;
-use subxt::{
-    dynamic::{DecodedValueThunk, Value},
-    storage::Address,
-    utils::Yes,
-    OnlineClient, PolkadotConfig,
-};
 use tracing::debug;
 
-// use pallet_storage_providers::types::MainStorageProvider;
-// use sh_solochain_evm_runtime::Runtime;
 use shc_indexer_db::OnchainMspId;
 use shc_rpc::{
     GetFileFromFileStorageResult, GetValuePropositionsResult, RpcProviderId, SaveFileToDisk,
 };
-// use sp_core::{blake2_256, storage::StorageKey, twox_128};
+use sp_core::storage::StorageKey;
 
 use crate::data::rpc::{
     connection::error::{RpcConnectionError, RpcResult},
@@ -86,20 +79,32 @@ impl StorageHubRpcClient {
     ///
     /// # Arguments:
     /// - `key` is the storage key to attempt reading
-    /// - `transform` is a closure to transform the raw storage value returned by the API into the target type
-    pub async fn query_storage<K, F, FT, R>(&self, key: K, transform: F) -> RpcResult<Option<R>>
+    pub async fn query_storage<R>(&self, key: StorageKey) -> RpcResult<Option<R>>
     where
-        K: Address<Target = DecodedValueThunk, IsFetchable = Yes>,
-        FT: Future<Output = RpcResult<Option<R>>>,
-        F: Fn(Result<Option<K::Target>, subxt::Error>) -> FT,
+        R: Decode,
     {
-        //FIXME: replace Config for DH/SH one
-        let api =
-            OnlineClient::<PolkadotConfig>::from_rpc_client(Arc::clone(&self.connection)).await?;
+        let encoded = format!("0x{}", hex::encode(&key.0));
+        debug!(key = encoded, "reading storage");
+
+        let response = self
+            .call::<_, Option<String>>(methods::STATE_QUERY, jsonrpsee::rpc_params![encoded])
+            .await?;
+
+        let Some(response) = response else {
+            return Ok(None);
+        };
 
-        let result = api.storage().at_latest().await?.fetch(&key).await;
+        // the RPC replies with scale-encoded response as a hex string
+        let response = hex::decode(response.trim_start_matches("0x")).map_err(|e| {
+            RpcConnectionError::Serialization(format!(
+                "RPC runtime API did not respond with a valid hex string: {}",
+                e.to_string()
+            ))
+        })?;
 
-        transform(result).await
+        R::decode(&mut response.as_slice())
+            .map(Some)
+            .map_err(|e| RpcConnectionError::Serialization(e.to_string()))
     }
 
     /// Call a JSON-RPC method on the connected node
@@ -138,47 +143,28 @@ impl StorageHubRpcClient {
             .map(|price| price.into())
     }
 
-    /// Retrieve the current available capacity for given provider, in storage units
-    pub async fn get_available_capacity(&self, provider: OnchainMspId) -> RpcResult<BigDecimal> {
-        debug!(target: "rpc::client::get_available_capacity", "Runtime API: get_available_capacity");
+    /// Retrieve the current number of active users
+    pub async fn get_number_of_active_users(&self, provider: OnchainMspId) -> RpcResult<usize> {
+        debug!(target: "rpc::client::get_number_of_active_users", "Runtime API: get_users_of_payment_streams_of_provider");
 
-        self.call_runtime_api::<_, runtime_apis::AvailableCapacity>(
-            runtime_apis::AVAILABLE_CAPACITY,
+        self.call_runtime_api::<_, runtime_apis::NumOfUsers>(
+            runtime_apis::NUM_OF_USERS,
             provider.as_h256(),
         )
         .await
-        .map(|capacity| capacity.into())
+        .map(|users| users.len())
     }
 
     /// Retrieve the MSP information for the given provider
     ///
     /// This function will read into the chain state from the Provider pallet's MainStorageProviders map
-    // TODO: replace return value with proper typing from runtime
     pub async fn get_msp_info(
         &self,
         provider: OnchainMspId,
     ) -> RpcResult<Option<state_queries::MspInfo>> {
         debug!(target: "rpc::client::get_msp", provider = %provider, "State Query: get_msp_info");
-        let key = subxt::dynamic::storage(
-            state_queries::MSP_INFO_MODULE,
-            state_queries::MSP_INFO_METHOD,
-            vec![Value::from_bytes(provider.as_bytes())],
-        );
-
-        self.query_storage(key, |storage| async move {
-            let Some(_value) = storage?
-                .map(|storage| storage.to_value())
-                .transpose()
-                .map_err(subxt::Error::from)?
-            else {
-                return Ok(None);
-            };
-
-            //FIXME: convert to MspInfo
-
-            Ok(None)
-        })
-        .await
+        self.query_storage(state_queries::msp_info_key(provider))
+            .await
     }
 
     /// Returns whether the given `file_key` is expected to be received by the MSP node

backend/lib/src/data/rpc/client.rs

@@ -28,36 +28,6 @@ pub enum RpcConnectionError {
     Other(String),
 }
 
-impl From<subxt::Error> for RpcConnectionError {
-    fn from(value: subxt::Error) -> Self {
-        match value {
-            subxt::Error::Io(error) => Self::Transport(error.to_string()),
-            subxt::Error::Rpc(rpc_error) => Self::Rpc(rpc_error.to_string()),
-            err @ subxt::Error::Runtime(_) | err @ subxt::Error::Transaction(_) => {
-                Self::Other(err.to_string())
-            }
-            err @ subxt::Error::Metadata(_)
-            | err @ subxt::Error::Block(_)
-            | err @ subxt::Error::Codec(_)
-            | err @ subxt::Error::MetadataDecoding(_)
-            | err @ subxt::Error::Extrinsic(_)
-            | err @ subxt::Error::StorageAddress(_)
-            | err @ subxt::Error::Serialization(_)
-            | err @ subxt::Error::Decode(_)
-            | err @ subxt::Error::Encode(_) => Self::Serialization(err.to_string()),
-            subxt::Error::Unknown(items) => Self::Serialization(format!(
-                "Unable to decode received data: {}",
-                hex::encode(items)
-            )),
-            subxt::Error::Other(other) => Self::Other(other),
-            unknown_variant => Self::Other(format!(
-                "Unknown error received from subxt: {:?}",
-                unknown_variant
-            )),
-        }
-    }
-}
-
 /// Result type for RPC operations
 pub type RpcResult<T> = Result<T, RpcConnectionError>;
 

backend/lib/src/data/rpc/connection/error.rs

@@ -5,8 +5,6 @@ use std::fmt::Debug;
 use async_trait::async_trait;
 use jsonrpsee::core::traits::ToRpcParams;
 use serde::de::DeserializeOwned;
-use serde_json::value::RawValue;
-use subxt::backend::rpc::RpcClientT;
 
 #[cfg(feature = "mocks")]
 use crate::data::rpc::mock_connection::MockConnection;
@@ -81,48 +79,3 @@ impl RpcConnection for AnyRpcConnection {
         }
     }
 }
-
-struct Params(Option<Box<RawValue>>);
-
-impl ToRpcParams for Params {
-    fn to_rpc_params(self) -> Result<Option<Box<RawValue>>, serde_json::Error> {
-        Ok(self.0)
-    }
-}
-
-// FIXME: implement
-#[allow(unused_variables)]
-impl RpcClientT for AnyRpcConnection {
-    fn request_raw<'a>(
-        &'a self,
-        method: &'a str,
-        params: Option<Box<RawValue>>,
-    ) -> subxt::backend::rpc::RawRpcFuture<'a, Box<RawValue>> {
-        Box::pin(async move {
-            match self {
-                AnyRpcConnection::Real(conn) => {
-                    conn.call(method, Params(params)).await.map_err(|e| todo!())
-                }
-                #[cfg(feature = "mocks")]
-                AnyRpcConnection::Mock(conn) => {
-                    conn.call(method, Params(params)).await.map_err(|e| todo!())
-                }
-            }
-        })
-    }
-
-    fn subscribe_raw<'a>(
-        &'a self,
-        sub: &'a str,
-        params: Option<Box<RawValue>>,
-        unsub: &'a str,
-    ) -> subxt::backend::rpc::RawRpcFuture<'a, subxt::backend::rpc::RawRpcSubscription> {
-        Box::pin(async move {
-            match self {
-                AnyRpcConnection::Real(ws_connection) => todo!(),
-                #[cfg(feature = "mocks")]
-                AnyRpcConnection::Mock(conn) => todo!(),
-            }
-        })
-    }
-}

backend/lib/src/data/rpc/connection/mod.rs

@@ -16,6 +16,7 @@ use tokio::{
 };
 use tracing::{debug, error};
 
+use frame_support::storage::StoragePrefixedMap;
 use shc_common::types::FileMetadata;
 use shc_rpc::{
     GetFileFromFileStorageResult, GetValuePropositionsResult, RpcProviderId, SaveFileToDisk,
@@ -30,7 +31,7 @@ use crate::{
     },
     data::rpc::{
         connection::error::{RpcConnectionError, RpcResult},
-        methods, runtime_apis, state_queries, RpcConnection,
+        methods, runtime_apis, RpcConnection,
     },
     models::msp_info::{ValueProposition, ValuePropositionWithId},
     test_utils::random_bytes_32,
@@ -159,9 +160,9 @@ impl MockConnection {
                 let price = format!("0x{}", hex::encode(MOCK_PRICE_PER_GIGA_UNIT.encode()));
                 serde_json::json!(price)
             }
-            runtime_apis::AVAILABLE_CAPACITY => {
-                // SCALE-encoded DUMMY MSP capacity
-                serde_json::json!("0x006db3fc1f00000000")
+            runtime_apis::NUM_OF_USERS => {
+                // SCALE-encoded DUMMY MSP users list
+                serde_json::json!("0x040b17ca3a1454cd058b231090c6fd635dd348659a")
             }
             api => {
                 error!(api= %hex::encode(api), "no mock registered for requested runtime api");
@@ -185,7 +186,10 @@ impl MockConnection {
 
         match storage_key {
             // we just always return the same MSP for this query
-            msp if msp.starts_with(state_queries::MSP_INFO_KEY_PREFIX.as_slice()) => {
+            msp if msp.starts_with(
+                crate::runtime::MainStorageProvidersStorageMap::final_prefix().as_slice(),
+            ) =>
+            {
                 // this is some sample data returned by the RPC during tests
                 // it should be the SCALE-encoded MainStorageProvider for the solochain runtime
                 serde_json::json!("0x0000002000000000934c0300000000000449012f6970342f3137322e31382e302e332f7463702f33303335302f7032702f313244334b6f6f575355767a38514d35583474664161534c4572415a6a523270756f6a6f313670554c42487971544d474b744e5601000000000000000000000000000000010000000d0000004c31b93792ab99e2553bff747199b7a4951185b24c31b93792ab99e2553bff747199b7a4951185b20d000000")
@@ -328,11 +332,13 @@ impl RpcConnection for MockConnection {
             }
             methods::API_CALL => self.mock_runtime_apis(params).await,
             methods::STATE_QUERY => self.mock_state_queries(params).await,
-            _ => {
+            method => {
                 let responses = self.responses.read().await;
-                responses
+                let response = responses
                     .get(method)
-                    .cloned()
+                    .cloned();
+
+                response
                     .unwrap_or(serde_json::json!(null))
             }
         };

backend/lib/src/data/rpc/mock_connection.rs

@@ -8,7 +8,7 @@ pub const CURRENT_PRICE: &str = "PaymentStreamsApi_get_current_price_per_giga_un
 // TODO: get type from runtime
 pub type CurrentPrice = u128;
 
-pub const AVAILABLE_CAPACITY: &str = "StorageProvidersApi_query_available_storage_capacity";
+pub const NUM_OF_USERS: &str = "PaymentStreamsApi_get_users_of_payment_streams_of_provider";
 
 // TODO: get type from runtime
-pub type AvailableCapacity = u64;
+pub type NumOfUsers = Vec<crate::runtime::AccountId>;