Merge remote-tracking branch 'origin/master' into lexnv/metadata_v15

subxt/src/client/online_client.rs

@@ -17,7 +17,7 @@ use crate::{
     tx::TxClient,
     Config, Metadata,
 };
-use codec::{Compact, Decode};
+use codec::Compact;
 use derivative::Derivative;
 use frame_metadata::RuntimeMetadataPrefixed;
 use futures::future;
@@ -136,10 +136,9 @@ impl<T: Config> OnlineClient<T> {
 
     /// Fetch the metadata from substrate using the runtime API.
     async fn fetch_metadata(rpc: &Rpc<T>) -> Result<Metadata, Error> {
-        let bytes = rpc.state_call("Metadata_metadata", None, None).await?;
-        let cursor = &mut &*bytes;
-        let _ = <Compact<u32>>::decode(cursor)?;
-        let meta: RuntimeMetadataPrefixed = Decode::decode(cursor)?;
+        let (_, meta) = rpc
+            .state_call::<(Compact<u32>, RuntimeMetadataPrefixed)>("Metadata_metadata", None, None)
+            .await?;
         Ok(meta.try_into()?)
     }
 

subxt/src/rpc/rpc.rs

@@ -31,16 +31,19 @@
 //! # }
 //! ```
 
+use std::sync::Arc;
+
+use codec::{Decode, Encode};
+use frame_metadata::RuntimeMetadataPrefixed;
+use serde::Serialize;
+
+use crate::{error::Error, utils::PhantomDataSendSync, Config, Metadata};
+
 use super::{
     rpc_params,
     types::{self, ChainHeadEvent, FollowEvent},
     RpcClient, RpcClientT, Subscription,
 };
-use crate::{error::Error, utils::PhantomDataSendSync, Config, Metadata};
-use codec::{Decode, Encode};
-use frame_metadata::RuntimeMetadataPrefixed;
-use serde::Serialize;
-use std::sync::Arc;
 
 /// Client for substrate rpc interfaces
 pub struct Rpc<T: Config> {
@@ -151,25 +154,6 @@ impl<T: Config> Rpc<T> {
         Ok(metadata)
     }
 
-    /// Execute a runtime API call.
-    pub async fn call(
-        &self,
-        function: String,
-        call_parameters: Option<&[u8]>,
-        at: Option<T::Hash>,
-    ) -> Result<types::Bytes, Error> {
-        let call_parameters = call_parameters.unwrap_or_default();
-
-        let bytes: types::Bytes = self
-            .client
-            .request(
-                "state_call",
-                rpc_params![function, to_hex(call_parameters), at],
-            )
-            .await?;
-        Ok(bytes)
-    }
-
     /// Fetch system properties
     pub async fn system_properties(&self) -> Result<types::SystemProperties, Error> {
         self.client
@@ -364,14 +348,13 @@ impl<T: Config> Rpc<T> {
     }
 
     /// Execute a runtime API call.
-    pub async fn state_call(
+    pub async fn state_call<Res: Decode>(
         &self,
         function: &str,
         call_parameters: Option<&[u8]>,
         at: Option<T::Hash>,
-    ) -> Result<types::Bytes, Error> {
+    ) -> Result<Res, Error> {
         let call_parameters = call_parameters.unwrap_or_default();
-
         let bytes: types::Bytes = self
             .client
             .request(
@@ -379,7 +362,9 @@ impl<T: Config> Rpc<T> {
                 rpc_params![function, to_hex(call_parameters), at],
             )
             .await?;
-        Ok(bytes)
+        let cursor = &mut &bytes[..];
+        let res: Res = Decode::decode(cursor)?;
+        Ok(res)
     }
 
     /// Create and submit an extrinsic and return a subscription to the events triggered.

subxt/src/runtime_api/runtime_types.rs

@@ -3,6 +3,7 @@
 // see LICENSE for license details.
 
 use crate::{client::OnlineClientT, error::Error, Config};
+use codec::Decode;
 use derivative::Derivative;
 use std::{future::Future, marker::PhantomData};
 
@@ -32,21 +33,21 @@ where
     Client: OnlineClientT<T>,
 {
     /// Execute a raw runtime API call.
-    pub fn call_raw<'a>(
+    pub fn call_raw<'a, Res: Decode>(
         &self,
         function: &'a str,
         call_parameters: Option<&'a [u8]>,
-    ) -> impl Future<Output = Result<Vec<u8>, Error>> + 'a {
+    ) -> impl Future<Output = Result<Res, Error>> + 'a {
         let client = self.client.clone();
         let block_hash = self.block_hash;
         // Ensure that the returned future doesn't have a lifetime tied to api.runtime_api(),
         // which is a temporary thing we'll be throwing away quickly:
         async move {
-            let data = client
+            let data: Res = client
                 .rpc()
                 .state_call(function, call_parameters, Some(block_hash))
                 .await?;
-            Ok(data.0)
+            Ok(data)
         }
     }
 }

subxt/src/tx/tx_client.rs

@@ -2,17 +2,18 @@
 // This file is dual-licensed as Apache-2.0 or GPL-3.0.
 // see LICENSE for license details.
 
-use super::TxPayload;
+use std::borrow::Cow;
+
+use codec::{Compact, Encode};
+use derivative::Derivative;
+
 use crate::{
     client::{OfflineClientT, OnlineClientT},
     config::{Config, ExtrinsicParams, Hasher},
     error::Error,
-    tx::{Signer as SignerT, TxProgress},
+    tx::{Signer as SignerT, TxPayload, TxProgress},
     utils::{Encoded, PhantomDataSendSync},
 };
-use codec::{Compact, Encode};
-use derivative::Derivative;
-use std::borrow::Cow;
 
 // This is returned from an API below, so expose it here.
 pub use crate::rpc::types::DryRunResult;
@@ -465,4 +466,23 @@ where
         let dry_run_bytes = self.client.rpc().dry_run(self.encoded(), at).await?;
         dry_run_bytes.into_dry_run_result(&self.client.metadata())
     }
+
+    /// This returns an estimate for what the extrinsic is expected to cost to execute, less any tips.
+    /// The actual amount paid can vary from block to block based on node traffic and other factors.
+    pub async fn partial_fee_estimate(&self) -> Result<u128, Error> {
+        let mut params = self.encoded().to_vec();
+        (self.encoded().len() as u32).encode_to(&mut params);
+        // destructuring RuntimeDispatchInfo, see type information <https://paritytech.github.io/substrate/master/pallet_transaction_payment_rpc_runtime_api/struct.RuntimeDispatchInfo.html>
+        // data layout: {weight_ref_time: Compact<u64>, weight_proof_size: Compact<u64>, class: u8, partial_fee: u128}
+        let (_, _, _, partial_fee) = self
+            .client
+            .rpc()
+            .state_call::<(Compact<u64>, Compact<u64>, u8, u128)>(
+                "TransactionPaymentApi_query_info",
+                Some(&params),
+                None,
+            )
+            .await?;
+        Ok(partial_fee)
+    }
 }

subxt/src/tx/tx_progress.rs

@@ -416,11 +416,7 @@ mod test {
 
     use crate::{
         client::{OfflineClientT, OnlineClientT},
-        config::{
-            extrinsic_params::BaseExtrinsicParams,
-            polkadot::{PlainTip, PolkadotConfig},
-            WithExtrinsicParams,
-        },
+        config::{extrinsic_params::BaseExtrinsicParams, polkadot::PlainTip, WithExtrinsicParams},
         error::RpcError,
         rpc::{types::SubstrateTxStatus, RpcSubscription, Subscription},
         tx::TxProgress,
@@ -429,15 +425,23 @@ mod test {
 
     use serde_json::value::RawValue;
 
+    type MockTxProgress = TxProgress<SubstrateConfig, MockClient>;
+    type MockHash = <WithExtrinsicParams<
+        SubstrateConfig,
+        BaseExtrinsicParams<SubstrateConfig, PlainTip>,
+    > as Config>::Hash;
+    type MockSubstrateTxStatus = SubstrateTxStatus<MockHash, MockHash>;
+
+    /// a mock client to satisfy trait bounds in tests
     #[derive(Clone, Debug)]
     struct MockClient;
 
-    impl OfflineClientT<PolkadotConfig> for MockClient {
+    impl OfflineClientT<SubstrateConfig> for MockClient {
         fn metadata(&self) -> crate::Metadata {
             panic!("just a mock impl to satisfy trait bounds")
         }
 
-        fn genesis_hash(&self) -> <PolkadotConfig as crate::Config>::Hash {
+        fn genesis_hash(&self) -> <SubstrateConfig as crate::Config>::Hash {
             panic!("just a mock impl to satisfy trait bounds")
         }
 
@@ -446,15 +450,8 @@ mod test {
         }
     }
 
-    type MockTxProgress = TxProgress<PolkadotConfig, MockClient>;
-    type MockHash = <WithExtrinsicParams<
-        SubstrateConfig,
-        BaseExtrinsicParams<SubstrateConfig, PlainTip>,
-    > as Config>::Hash;
-    type MockSubstrateTxStatus = SubstrateTxStatus<MockHash, MockHash>;
-
-    impl OnlineClientT<PolkadotConfig> for MockClient {
-        fn rpc(&self) -> &crate::rpc::Rpc<PolkadotConfig> {
+    impl OnlineClientT<SubstrateConfig> for MockClient {
+        fn rpc(&self) -> &crate::rpc::Rpc<SubstrateConfig> {
             panic!("just a mock impl to satisfy trait bounds")
         }
     }