qol avail-rust

avail-rust/docs/book/src/examples/transactions.rs

@@ -1,4 +1,4 @@
-use avail_rust::{avail, block::Block, error::ClientError, utils, Options, SDK};
+use avail_rust::{avail, error::ClientError, utils, Block, Options, SDK};
 
 pub async fn run() -> Result<(), ClientError> {
 	let sdk = SDK::new(SDK::local_endpoint()).await?;

avail-rust/docs/book/src/storage/mod.rs

@@ -3,7 +3,7 @@ use avail_rust::{
 	error::ClientError,
 	rpcs,
 	utils::account_id_from_str,
-	AccountId, SDK,
+	AccountId, Block, SDK,
 };
 
 pub async fn da_app_keys() -> Result<(), ClientError> {
@@ -14,7 +14,7 @@ pub async fn da_app_keys() -> Result<(), ClientError> {
 	let key = BoundedVec(key.as_bytes().to_vec());
 	let storage_query = avail::storage().data_availability().app_keys(key);
 
-	let best_block_hash = rpcs::get_best_block_hash(rpc_client).await?;
+	let best_block_hash = Block::fetch_best_block_hash(rpc_client).await?;
 	let storage = online_client.storage().at(best_block_hash);
 	let result = storage.fetch(&storage_query).await?;
 
@@ -29,7 +29,7 @@ pub async fn da_app_keys_iter() -> Result<(), ClientError> {
 
 	let storage_query = avail::storage().data_availability().app_keys_iter();
 
-	let best_block_hash = rpcs::get_best_block_hash(rpc_client).await?;
+	let best_block_hash = Block::fetch_best_block_hash(rpc_client).await?;
 	let storage = online_client.storage().at(best_block_hash);
 	let mut results = storage.iter(storage_query).await?;
 
@@ -50,7 +50,7 @@ pub async fn da_next_app_id() -> Result<(), ClientError> {
 
 	let storage_query = avail::storage().data_availability().next_app_id();
 
-	let best_block_hash = rpcs::get_best_block_hash(rpc_client).await?;
+	let best_block_hash = Block::fetch_best_block_hash(rpc_client).await?;
 	let storage = online_client.storage().at(best_block_hash);
 	let result = storage.fetch_or_default(&storage_query).await?;
 
@@ -64,7 +64,7 @@ pub async fn staking_active_era() -> Result<(), ClientError> {
 	let (online_client, rpc_client) = (&sdk.online_client, &sdk.rpc_client);
 
 	let storage_query = avail::storage().staking().active_era();
-	let best_block_hash = rpcs::get_best_block_hash(rpc_client).await?;
+	let best_block_hash = Block::fetch_best_block_hash(rpc_client).await?;
 	let storage = online_client.storage().at(best_block_hash);
 	let result = storage.fetch(&storage_query).await?;
 
@@ -80,7 +80,7 @@ pub async fn staking_bonded() -> Result<(), ClientError> {
 	let account_id = account_id_from_str("5GNJqTPyNqANBkUVMN1LPPrxXnFouWXoe2wNSmmEoLctxiZY")?; // Alice_Stash
 
 	let storage_query = avail::storage().staking().bonded(account_id);
-	let best_block_hash = rpcs::get_best_block_hash(rpc_client).await?;
+	let best_block_hash = Block::fetch_best_block_hash(rpc_client).await?;
 	let storage = online_client.storage().at(best_block_hash);
 	let result = storage.fetch(&storage_query).await?;
 
@@ -94,7 +94,7 @@ pub async fn staking_bonded_iter() -> Result<(), ClientError> {
 	let (online_client, rpc_client) = (&sdk.online_client, &sdk.rpc_client);
 
 	let storage_query = avail::storage().staking().bonded_iter();
-	let best_block_hash = rpcs::get_best_block_hash(rpc_client).await?;
+	let best_block_hash = Block::fetch_best_block_hash(rpc_client).await?;
 	let storage = online_client.storage().at(best_block_hash);
 	let mut results = storage.iter(storage_query).await?;
 
@@ -114,7 +114,7 @@ pub async fn system_account_iter() -> Result<(), ClientError> {
 	let (online_client, rpc_client) = (&sdk.online_client, &sdk.rpc_client);
 
 	let storage_query = avail::storage().system().account_iter();
-	let best_block_hash = rpcs::get_best_block_hash(rpc_client).await?;
+	let best_block_hash = Block::fetch_best_block_hash(rpc_client).await?;
 	let storage = online_client.storage().at(best_block_hash);
 	let mut results = storage.iter(storage_query).await?;
 

avail-rust/src/account.rs

@@ -1,12 +1,11 @@
 use std::str::FromStr;
-
 use subxt::{backend::rpc::RpcClient, blocks::StaticExtrinsic, ext::scale_encode::EncodeAsFields};
 
 use crate::{
 	avail,
 	error::ClientError,
 	rpcs::get_block_hash,
-	transactions::{Transaction, TransactionDetails, TransactionFailed},
+	transactions::{Transaction, TransactionDetails},
 	utils, AOnlineClient, AccountId, Keypair, Options, SecretUri, WaitFor, SDK,
 };
 
@@ -80,11 +79,11 @@ impl Account {
 		tx: Transaction<T>,
 		wait_for: WaitFor,
 		options: Option<Options>,
-	) -> Result<TransactionDetails, TransactionFailed>
+	) -> Result<TransactionDetails, ClientError>
 	where
 		T: StaticExtrinsic + EncodeAsFields,
 	{
-		tx.execute(wait_for, &self.keyring, options).await
+		tx.execute(wait_for, &self.keyring, options, Some(6)).await
 	}
 
 	pub async fn get_nonce_state(

avail-rust/src/block.rs

@@ -1,5 +1,5 @@
 use crate::error::ClientError;
-use crate::rpcs::{get_best_block_hash, get_block_hash, get_finalized_head};
+use crate::rpcs;
 use crate::{
 	avail::data_availability::calls::types as DataAvailabilityCalls,
 	primitives::block::extrinsics_params::CheckAppId,
@@ -33,16 +33,16 @@ impl Block {
 		online_client: &AOnlineClient,
 		rpc_client: &RpcClient,
 	) -> Result<Self, subxt::Error> {
-		let best_hash = get_best_block_hash(rpc_client).await?;
-		Self::new(online_client, best_hash).await
+		let block_hash = Self::fetch_best_block_hash(rpc_client).await?;
+		Self::new(online_client, block_hash).await
 	}
 
 	pub async fn new_finalized_block(
 		online_client: &AOnlineClient,
 		rpc_client: &RpcClient,
 	) -> Result<Self, subxt::Error> {
-		let best_hash = get_finalized_head(rpc_client).await?;
-		Self::new(online_client, best_hash).await
+		let block_hash = Self::fetch_finalized_block_hash(rpc_client).await?;
+		Self::new(online_client, block_hash).await
 	}
 
 	pub async fn from_block(block: ABlock) -> Result<Self, subxt::Error> {
@@ -58,7 +58,7 @@ impl Block {
 		rpc_client: &RpcClient,
 		block_number: u32,
 	) -> Result<Self, subxt::Error> {
-		let block_hash = get_block_hash(rpc_client, Some(block_number)).await?;
+		let block_hash = rpcs::get_block_hash(rpc_client, Some(block_number)).await?;
 		Self::new(online_client, block_hash).await
 	}
 
@@ -175,6 +175,14 @@ impl Block {
 	{
 		self.block.storage().iter(address).await
 	}
+
+	pub async fn fetch_best_block_hash(client: &RpcClient) -> Result<H256, subxt::Error> {
+		rpcs::get_block_hash(client, None).await
+	}
+
+	pub async fn fetch_finalized_block_hash(client: &RpcClient) -> Result<H256, subxt::Error> {
+		rpcs::get_finalized_head(client).await
+	}
 }
 
 pub async fn fetch_transactions(

avail-rust/src/lib.rs

@@ -28,6 +28,7 @@ pub use sdk::{WaitFor, SDK};
 
 pub use crate::avail::runtime_types::sp_arithmetic::per_things::Perbill;
 pub use avail_core;
+pub use block::Block;
 pub use hex;
 pub use kate_recovery;
 pub use primitives::block::{

avail-rust/src/rpcs.rs

@@ -274,10 +274,6 @@ pub async fn get_block_hash(
 	Ok(value)
 }
 
-pub async fn get_best_block_hash(client: &RpcClient) -> Result<BlockHash, subxt::Error> {
-	get_block_hash(client, None).await
-}
-
 pub async fn get_finalized_head(client: &RpcClient) -> Result<BlockHash, subxt::Error> {
 	let value: BlockHash = client
 		.request("chain_getFinalizedHead", rpc_params![])

avail-rust/src/transactions/mod.rs

@@ -10,7 +10,7 @@ use crate::{
 	from_substrate::FeeDetails,
 	rpcs::query_fee_details,
 	utils::{self, *},
-	AExtrinsicEvents, AOnlineClient, ATxInBlock, AvailConfig, WaitFor, H256,
+	AExtrinsicEvents, AOnlineClient, AvailConfig, WaitFor, H256,
 };
 
 use options::parse_options;
@@ -68,7 +68,6 @@ impl Transactions {
 
 #[derive(Debug, Clone)]
 pub struct TransactionDetails {
-	pub tx_in_block: Arc<ATxInBlock>,
 	pub events: Arc<AExtrinsicEvents>,
 	pub tx_hash: H256,
 	pub tx_index: u32,
@@ -78,15 +77,13 @@ pub struct TransactionDetails {
 
 impl TransactionDetails {
 	pub fn new(
-		tx_in_block: ATxInBlock,
 		events: AExtrinsicEvents,
 		tx_hash: H256,
 		tx_index: u32,
 		block_hash: H256,
 		block_number: u32,
 	) -> Self {
 		Self {
-			tx_in_block: tx_in_block.into(),
 			events: events.into(),
 			tx_hash,
 			tx_index,
@@ -269,17 +266,17 @@ where
 		&self,
 		account: &Keypair,
 		options: Option<Options>,
-	) -> Result<TransactionDetails, TransactionFailed> {
-		self.execute(WaitFor::BlockInclusion, account, options)
+	) -> Result<TransactionDetails, ClientError> {
+		self.execute(WaitFor::BlockInclusion, account, options, Some(3))
 			.await
 	}
 
 	pub async fn execute_wait_for_finalization(
 		&self,
 		account: &Keypair,
 		options: Option<Options>,
-	) -> Result<TransactionDetails, TransactionFailed> {
-		self.execute(WaitFor::BlockFinalization, account, options)
+	) -> Result<TransactionDetails, ClientError> {
+		self.execute(WaitFor::BlockFinalization, account, options, Some(6))
 			.await
 	}
 
@@ -288,14 +285,16 @@ where
 		wait_for: WaitFor,
 		account: &Keypair,
 		options: Option<Options>,
-	) -> Result<TransactionDetails, TransactionFailed> {
-		progress_and_parse_transaction(
+		block_timeout: Option<u32>,
+	) -> Result<TransactionDetails, ClientError> {
+		execute_and_watch_transaction(
 			&self.online_client,
 			&self.rpc_client,
 			account,
 			&self.payload,
 			wait_for,
 			options,
+			block_timeout,
 		)
 		.await
 	}
@@ -315,6 +314,15 @@ where
 		.await
 	}
 
+	pub async fn watch_transaction(
+		online_client: &AOnlineClient,
+		tx_hash: H256,
+		wait_for: WaitFor,
+		block_timeout: Option<u32>,
+	) -> Result<TransactionDetails, ClientError> {
+		watch_transaction(online_client, tx_hash, wait_for, block_timeout).await
+	}
+
 	pub async fn payment_query_info(
 		&self,
 		account: &Keypair,

avail-rust/src/transactions/options.rs

@@ -1,7 +1,8 @@
 use subxt::backend::rpc::RpcClient;
 
 use crate::error::ClientError;
-use crate::rpcs::{account_next_index, get_block_hash, get_finalized_head, get_header};
+use crate::rpcs::{account_next_index, get_block_hash, get_header};
+use crate::Block;
 use crate::{AOnlineClient, AccountId, AvailExtrinsicParamsBuilder, BlockHash};
 
 use super::Params;
@@ -110,7 +111,7 @@ pub async fn parse_options(
 				builder.nonce(nonce)
 			},
 			Nonce::FinalizedBlock => {
-				let hash = get_finalized_head(rpc_client).await?;
+				let hash = Block::fetch_finalized_block_hash(rpc_client).await?;
 				let block = online_client.blocks().at(hash).await?;
 				let nonce = block.account_nonce(&account).await?;
 				builder.nonce(nonce)