Add failed extrinsic error (#725)

* add failed extrinsic error

* fix no_std build

* ensure events are in the error report

src/api/error.rs

@@ -15,12 +15,13 @@
 
 */
 
-use crate::{api::UnexpectedTxStatus, rpc::Error as RpcClientError};
+use crate::{api::UnexpectedTxStatus, rpc::Error as RpcClientError, ExtrinsicReport};
 use ac_node_api::{
  error::DispatchError,
  metadata::{MetadataConversionError, MetadataError},
 };
-use alloc::boxed::Box;
+use alloc::{boxed::Box, vec::Vec};
+use codec::{Decode, Encode};
 
 pub type Result<T> = core::result::Result<T, Error>;
 
@@ -42,8 +43,8 @@ pub enum Error {
  Codec(codec::Error),
  /// Could not convert NumberOrHex with try_from.
  TryFromIntError,
- /// Node Api Dispatch Error.
- Dispatch(DispatchError),
+ /// Extrinsic failed onchain. Contains the encoded report and the associated dispatch error.
+ FailedExtrinsic(FailedExtrinsicError),
  /// Encountered unexpected tx status during watch process.
  UnexpectedTxStatus(UnexpectedTxStatus),
  /// Could not send update because the Stream has been closed unexpectedly.
@@ -57,3 +58,29 @@ pub enum Error {
  /// Any custom Error.
  Other(Box<dyn core::error::Error + Send + Sync + 'static>),
 }
+
+/// Encountered unexpected tx status during watch process or the extrinsic failed.
+#[derive(Debug)]
+pub struct FailedExtrinsicError {
+ dispatch_error: DispatchError,
+ encoded_report: Vec<u8>,
+}
+
+impl FailedExtrinsicError {
+ pub fn new(dispatch_error: DispatchError, encoded_report: Vec<u8>) -> Self {
+ Self { dispatch_error, encoded_report }
+ }
+
+ pub fn dispatch_error(&self) -> &DispatchError {
+ &self.dispatch_error
+ }
+
+ pub fn get_report<Hash: Encode + Decode>(&self) -> Result<ExtrinsicReport<Hash>> {
+ let report = Decode::decode(&mut self.encoded_report.as_slice())?;
+ Ok(report)
+ }
+
+ pub fn encoded_report(&self) -> &[u8] {
+ &self.encoded_report
+ }
+}

src/api/rpc_api/author.rs

@@ -15,6 +15,7 @@
 
 use crate::{
  api::{rpc_api::events::FetchEvents, Error, Result},
+ error::FailedExtrinsicError,
  rpc::{HandleSubscription, Request, Subscribe},
  Api, ExtrinsicReport, TransactionStatus, XtStatus,
 };
@@ -279,14 +280,24 @@ where
  let extrinsic_events =
  self.fetch_events_for_extrinsic(block_hash, report.extrinsic_hash).await?;
 
- // Ensure the extrinsic was successful. If not, return an error.
+ // Check if the extrinsic was succesfull or not.
+ let mut maybe_dispatch_error = None;
  for event in &extrinsic_events {
  if let Some(dispatch_error) = event.get_associated_dispatch_error() {
- return Err(Error::Dispatch(dispatch_error))
+ maybe_dispatch_error = Some(dispatch_error);
+ break
  }
  }
+
  report.events = Some(extrinsic_events.into_iter().map(|event| event.to_raw()).collect());
 
+ if let Some(dispatch_error) = maybe_dispatch_error {
+ return Err(Error::FailedExtrinsic(FailedExtrinsicError::new(
+ dispatch_error,
+ report.encode(),
+ )))
+ }
+
  Ok(report)
  }
 

testing/async/examples/dispatch_errors_tests.rs

@@ -15,11 +15,12 @@
 
 //! Tests for the dispatch error.
 
+use sp_core::H256;
 use sp_keyring::AccountKeyring;
 use sp_runtime::MultiAddress;
 use substrate_api_client::{
  ac_primitives::AssetRuntimeConfig, extrinsic::BalancesExtrinsics, rpc::JsonrpseeClient, Api,
- GetAccountInformation, SubmitAndWatch, XtStatus,
+ Error, GetAccountInformation, SubmitAndWatch, XtStatus,
 };
 
 #[tokio::main]
@@ -51,8 +52,16 @@ async fn main() {
  .unwrap();
 
  let result = api.submit_and_watch_extrinsic_until(xt, XtStatus::InBlock).await;
- assert!(result.is_err());
- assert!(format!("{result:?}").contains("BadOrigin"));
+ match result {
+ Err(Error::FailedExtrinsic(extrinsic_error)) => {
+ let dispatch_error = extrinsic_error.dispatch_error();
+ let report = extrinsic_error.get_report::<H256>().unwrap();
+ assert!(report.block_hash.is_some());
+ assert!(report.events.is_some());
+ assert!(format!("{dispatch_error:?}").contains("BadOrigin"));
+ },
+ _ => panic!("Expected Failed Extrinisc Error"),
+ }
  println!("[+] BadOrigin error: Bob can't force set balance");
 
  //BelowMinimum
@@ -62,7 +71,14 @@ async fn main() {
  .await
  .unwrap();
  let result = api.submit_and_watch_extrinsic_until(xt, XtStatus::InBlock).await;
- assert!(result.is_err());
- assert!(format!("{result:?}").contains("(BelowMinimum"));
+ match result {
+ Err(Error::FailedExtrinsic(extrinsic_error)) => {
+ let dispatch_error = extrinsic_error.dispatch_error();
+ let report = extrinsic_error.get_report::<H256>().unwrap();
+ assert!(report.block_hash.is_some());
+ assert!(format!("{dispatch_error:?}").contains("BelowMinimum"));
+ },
+ _ => panic!("Expected Failed Extrinisc Error"),
+ }
  println!("[+] BelowMinimum error: balance (999999) is below the existential deposit");
 }