hacky

Cargo.toml

@@ -24,7 +24,7 @@ chameleon = "0.1.0"
 scale-info = { version = "1.0.0", features = ["bit-vec"] }
 futures = "0.3.13"
 hex = "0.4.3"
-jsonrpsee = { git = "https://github.com/paritytech/jsonrpsee/", branch = "master", features = ["macros", "core-client", "client", "client-ws-transport"] }
+jsonrpsee = { git = "https://github.com/paritytech/jsonrpsee/", branch = "jsonrpsee-clients-expose-tls-feature", features = ["macros", "core-client", "client", "client-ws-transport"] }
 log = "0.4.14"
 num-traits = { version = "0.2.14", default-features = false }
 serde = { version = "1.0.124", features = ["derive"] }

examples/submit_and_watch.rs

@@ -61,7 +61,7 @@ async fn simple_transfer() -> Result<(), Box<dyn std::error::Error>> {
         .sign_and_submit_then_watch(&signer)
         .await?
         .wait_for_finalized_success()
-        .await?;
+        .await.unwrap()?;
 
     let transfer_event =
         balance_transfer.find_first_event::<polkadot::balances::events::Transfer>()?;
@@ -93,7 +93,7 @@ async fn simple_transfer_separate_events() -> Result<(), Box<dyn std::error::Err
         .sign_and_submit_then_watch(&signer)
         .await?
         .wait_for_finalized()
-        .await?;
+        .await.unwrap()?;
 
     // Now we know it's been finalized, we can get hold of a couple of
     // details, including events. Calling `wait_for_finalized_success` is
@@ -144,8 +144,9 @@ async fn handle_transfer_events() -> Result<(), Box<dyn std::error::Error>> {
         .sign_and_submit_then_watch(&signer)
         .await?;
 
-    while let Some(ev) = balance_transfer_progress.next().await? {
+    loop {
         use subxt::TransactionStatus::*;
+        let ev = balance_transfer_progress.next().await.unwrap()?;
 
         // Made it into a block, but not finalized.
         if let InBlock(details) = ev {
@@ -191,6 +192,4 @@ async fn handle_transfer_events() -> Result<(), Box<dyn std::error::Error>> {
             println!("Current transaction status: {:?}", ev);
         }
     }
-
-    Ok(())
 }

src/rpc.rs

@@ -451,99 +451,6 @@ impl<T: Config> Rpc<T> {
         Ok(subscription)
     }
 
-    /// Create and submit an extrinsic and return corresponding Event if successful
-    pub async fn submit_and_watch_extrinsic<'a, E: Encode + 'static>(
-        &self,
-        extrinsic: E,
-        decoder: &'a EventsDecoder<T>,
-    ) -> Result<ExtrinsicSuccess<T>, Error> {
-        let ext_hash = T::Hashing::hash_of(&extrinsic);
-        log::info!("Submitting Extrinsic `{:?}`", ext_hash);
-
-        let events_sub = if self.accept_weak_inclusion {
-            self.subscribe_events().await
-        } else {
-            self.subscribe_finalized_events().await
-        }?;
-        let mut xt_sub = self.watch_extrinsic(extrinsic).await?;
-
-        while let Some(status) = xt_sub.next().await {
-            log::info!("Received status {:?}", status);
-            let status = status?;
-            match status {
-                TransactionStatus::Future
-                | TransactionStatus::Ready
-                | TransactionStatus::Broadcast(_)
-                | TransactionStatus::Retracted(_) => continue,
-                TransactionStatus::InBlock(block_hash) => {
-                    if self.accept_weak_inclusion {
-                        return self
-                            .process_block(events_sub, decoder, block_hash, ext_hash)
-                            .await
-                    }
-                    continue
-                }
-                TransactionStatus::Invalid => return Err("Extrinsic Invalid".into()),
-                TransactionStatus::Usurped(_) => return Err("Extrinsic Usurped".into()),
-                TransactionStatus::Dropped => return Err("Extrinsic Dropped".into()),
-                TransactionStatus::Finalized(block_hash) => {
-                    // read finalized blocks by default
-                    return self
-                        .process_block(events_sub, decoder, block_hash, ext_hash)
-                        .await
-                }
-                TransactionStatus::FinalityTimeout(_) => {
-                    return Err("Extrinsic FinalityTimeout".into())
-                }
-            }
-        }
-        Err(RpcError::Custom("RPC subscription dropped".into()).into())
-    }
-
-    async fn process_block(
-        &self,
-        events_sub: EventStorageSubscription<T>,
-        decoder: &EventsDecoder<T>,
-        block_hash: T::Hash,
-        ext_hash: T::Hash,
-    ) -> Result<ExtrinsicSuccess<T>, Error> {
-        log::info!("Fetching block {:?}", block_hash);
-        if let Some(signed_block) = self.block(Some(block_hash)).await? {
-            log::info!(
-                "Found block {:?}, with {} extrinsics",
-                block_hash,
-                signed_block.block.extrinsics.len()
-            );
-            let ext_index = signed_block
-                .block
-                .extrinsics
-                .iter()
-                .position(|ext| {
-                    let hash = T::Hashing::hash_of(ext);
-                    hash == ext_hash
-                })
-                .ok_or_else(|| {
-                    Error::Other(format!(
-                        "Failed to find Extrinsic with hash {:?}",
-                        ext_hash,
-                    ))
-                })?;
-            let mut sub = EventSubscription::new(events_sub, decoder);
-            sub.filter_extrinsic(block_hash, ext_index);
-            let mut events = vec![];
-            while let Some(event) = sub.next().await {
-                events.push(event?);
-            }
-            Ok(ExtrinsicSuccess {
-                block: block_hash,
-                extrinsic: ext_hash,
-                events,
-            })
-        } else {
-            Err(format!("Failed to find block {:?}", block_hash).into())
-        }
-    }
-
     /// Insert a key into the keystore.
     pub async fn insert_key(
         &self,
@@ -587,38 +494,6 @@ impl<T: Config> Rpc<T> {
     }
 }
 
-/// Captures data for when an extrinsic is successfully included in a block
-#[derive(Debug)]
-pub struct ExtrinsicSuccess<T: Config> {
-    /// Block hash.
-    pub block: T::Hash,
-    /// Extrinsic hash.
-    pub extrinsic: T::Hash,
-    /// Raw runtime events, can be decoded by the caller.
-    pub events: Vec<RawEvent>,
-}
-
-impl<T: Config> ExtrinsicSuccess<T> {
-    /// Find the Event for the given module/variant, with raw encoded event data.
-    /// Returns `None` if the Event is not found.
-    pub fn find_event_raw(&self, module: &str, variant: &str) -> Option<&RawEvent> {
-        self.events
-            .iter()
-            .find(|raw| raw.pallet == module && raw.variant == variant)
-    }
-
-    /// Find the Event for the given module/variant, attempting to decode the event data.
-    /// Returns `None` if the Event is not found.
-    /// Returns `Err` if the data fails to decode into the supplied type.
-    pub fn find_event<E: Event>(&self) -> Result<Option<E>, CodecError> {
-        if let Some(event) = self.find_event_raw(E::PALLET, E::EVENT) {
-            Ok(Some(E::decode(&mut &event.data[..])?))
-        } else {
-            Ok(None)
-        }
-    }
-}
-
 /// Build WS RPC client from URL
 pub async fn build_ws_client(url: &str) -> Result<RpcClient, RpcError> {
     let (sender, receiver) = ws_transport(url).await?;

src/transaction.rs

@@ -30,10 +30,7 @@ use crate::{
     Config,
     Phase,
 };
-use jsonrpsee::types::{
-    Error as RpcError,
-    Subscription as RpcSubscription,
-};
+use jsonrpsee::core::client::Subscription as RpcSubscription;
 
 /// This struct represents a subscription to the progress of some transaction, and is
 /// returned from [`crate::SubmittableExtrinsic::sign_and_submit_then_watch()`].
@@ -58,16 +55,16 @@ impl<'client, T: Config> TransactionProgress<'client, T> {
     }
 
     /// Return the next transaction status when it's emitted.
-    pub async fn next(&mut self) -> Result<Option<TransactionStatus<'client, T>>, Error> {
+    pub async fn next(&mut self) -> Option<Result<TransactionStatus<'client, T>, Error>> {
         // Return `None` if the subscription has been dropped:
         let sub = match &mut self.sub {
             Some(sub) => sub,
-            None => return Ok(None),
+            None => return None,
         };
 
         // Return the next item otherwise:
         let res = sub.next().await?;
-        Ok(res.map(|status| {
+        Some(res.map(|status| {
             match status {
                 SubstrateTransactionStatus::Future => TransactionStatus::Future,
                 SubstrateTransactionStatus::Ready => TransactionStatus::Ready,
@@ -111,7 +108,7 @@ impl<'client, T: Config> TransactionProgress<'client, T> {
                     })
                 }
             }
-        }))
+        }).map_err(Into::into))
     }
 
     /// Wait for the transaction to be in a block (but not necessarily finalized), and return
@@ -127,22 +124,24 @@ impl<'client, T: Config> TransactionProgress<'client, T> {
     /// level [`TransactionProgress::next()`] API if you'd like to handle these statuses yourself.
     pub async fn wait_for_in_block(
         mut self,
-    ) -> Result<TransactionInBlock<'client, T>, Error> {
-        while let Some(status) = self.next().await? {
-            match status {
-                // Finalized or otherwise in a block! Return.
-                TransactionStatus::InBlock(s) | TransactionStatus::Finalized(s) => {
-                    return Ok(s)
-                }
-                // Error scenarios; return the error.
-                TransactionStatus::FinalityTimeout(_) => {
-                    return Err(TransactionError::FinalitySubscriptionTimeout.into())
+    ) -> Option<Result<TransactionInBlock<'client, T>, Error>> {
+        loop {
+            match self.next().await? {
+                Ok(status) => match status {
+                    // Finalized or otherwise in a block! Return.
+                    TransactionStatus::InBlock(s) | TransactionStatus::Finalized(s) => {
+                        return Some(Ok(s))
+                    }
+                    // Error scenarios; return the error.
+                    TransactionStatus::FinalityTimeout(_) => {
+                        return Some(Err(TransactionError::FinalitySubscriptionTimeout.into()))
+                    }
+                    // Ignore anything else and wait for next status event:
+                    _ => continue,
                 }
-                // Ignore anything else and wait for next status event:
-                _ => continue,
+                Err(err) => return Some(Err(err)),
             }
         }
-        Err(RpcError::Custom("RPC subscription dropped".into()).into())
     }
 
     /// Wait for the transaction to be finalized, and return a [`TransactionInBlock`]
@@ -157,20 +156,22 @@ impl<'client, T: Config> TransactionProgress<'client, T> {
     /// level [`TransactionProgress::next()`] API if you'd like to handle these statuses yourself.
     pub async fn wait_for_finalized(
         mut self,
-    ) -> Result<TransactionInBlock<'client, T>, Error> {
-        while let Some(status) = self.next().await? {
-            match status {
-                // Finalized! Return.
-                TransactionStatus::Finalized(s) => return Ok(s),
-                // Error scenarios; return the error.
-                TransactionStatus::FinalityTimeout(_) => {
-                    return Err(TransactionError::FinalitySubscriptionTimeout.into())
+    ) -> Option<Result<TransactionInBlock<'client, T>, Error>> {
+        loop {
+            match self.next().await? {
+                Ok(status) => match status {
+                    // finalized! return.
+                    TransactionStatus::Finalized(s) => return Some(Ok(s)),
+                    // error scenarios; return the error.
+                    TransactionStatus::FinalityTimeout(_) => {
+                        return Some(Err(TransactionError::FinalitySubscriptionTimeout.into()))
+                    }
+                    // ignore and wait for next status event:
+                    _ => continue,
                 }
-                // Ignore and wait for next status event:
-                _ => continue,
+                Err(err) => return Some(Err(err)),
             }
         }
-        Err(RpcError::Custom("RPC subscription dropped".into()).into())
     }
 
     /// Wait for the transaction to be finalized, and for the transaction events to indicate
@@ -184,9 +185,13 @@ impl<'client, T: Config> TransactionProgress<'client, T> {
     /// may well indicate with some probability that the transaction will not make it into a block,
     /// there is no guarantee that this is true. Thus, we prefer to "play it safe" here. Use the lower
     /// level [`TransactionProgress::next()`] API if you'd like to handle these statuses yourself.
-    pub async fn wait_for_finalized_success(self) -> Result<TransactionEvents<T>, Error> {
-        let evs = self.wait_for_finalized().await?.wait_for_success().await?;
-        Ok(evs)
+    pub async fn wait_for_finalized_success(self) -> Option<Result<TransactionEvents<T>, Error>> {
+        let finalized = match self.wait_for_finalized().await? {
+            Ok(f) => f,
+            Err(err) => return Some(Err(err)),
+        };
+
+        Some(finalized.wait_for_success().await)
     }
 }