avail-rust-client 0.5.1

use crate::{
	Client, Error, ExtrinsicDecodable, UserError,
	block::{
		BlockExtrinsicMetadata,
		encoded::{BlockEncodedExtrinsic, BlockEncodedExtrinsicsQuery},
		events::{BlockEvents, BlockEventsQuery},
		extrinsic_options::Options,
		signed::BlockSignedExtrinsic,
	},
};
use avail_rust_core::{
	ExtrinsicSignature, H256, HasHeader, MultiAddress, RpcError, rpc::ExtrinsicFilter, types::HashStringNumber,
};
use codec::Decode;

/// View of block extrinsics decoded into calls and optional signatures.
pub struct BlockExtrinsicsQuery {
	xt: BlockEncodedExtrinsicsQuery,
}

impl BlockExtrinsicsQuery {
	/// Builds a decoded extrinsic view for the specified block.
	///
	/// # Parameters
	/// - `client`: RPC client used to fetch encoded extrinsics before decoding.
	/// - `block_id`: Identifier convertible into `HashStringNumber`.
	///
	/// # Returns
	/// - `Self`: Helper that decodes extrinsics on demand.
	pub fn new(client: Client, block_id: HashStringNumber) -> Self {
		Self { xt: BlockEncodedExtrinsicsQuery::new(client, block_id) }
	}

	/// Fetches a specific extrinsic by hash, index, or string identifier.
	///
	/// # Parameters
	/// - `extrinsic_id`: Identifier used to select the extrinsic.
	///
	/// # Returns
	/// - `Ok(Some(Extrinsic<T>))`: Matching extrinsic decoded as `T`.
	/// - `Ok(None)`: No extrinsic matched the identifier.
	/// - `Err(Error)`: Identifier decoding, the RPC call, or payload decoding failed.
	///
	/// # Side Effects
	/// - Performs RPC calls via the encoded-extrinsic helper and may retry according to the retry policy.
	pub async fn get<T: HasHeader + Decode>(
		&self,
		extrinsic_id: impl Into<HashStringNumber>,
	) -> Result<Option<BlockExtrinsic<T>>, Error> {
		async fn inner<T: HasHeader + Decode>(
			s: &BlockExtrinsicsQuery,
			extrinsic_id: HashStringNumber,
		) -> Result<Option<BlockExtrinsic<T>>, Error> {
			let filter = match extrinsic_id {
				HashStringNumber::Hash(x) => ExtrinsicFilter::from(x),
				HashStringNumber::String(x) => ExtrinsicFilter::try_from(x).map_err(UserError::Decoding)?,
				HashStringNumber::Number(x) => ExtrinsicFilter::from(x),
			};
			s.first::<T>(Options::new().filter(filter)).await
		}

		inner::<T>(self, extrinsic_id.into()).await
	}

	/// Returns the first extrinsic that matches the supplied filters.
	///
	/// # Parameters
	/// - `opts`: Filters describing which extrinsic to fetch.
	///
	/// # Returns
	/// - `Ok(Some(Extrinsic<T>))`: First matching extrinsic decoded as `T`.
	/// - `Ok(None)`: No extrinsic satisfied the filters.
	/// - `Err(Error)`: The RPC call or payload decoding failed.
	///
	/// # Side Effects
	/// - Performs RPC calls via the encoded-extrinsic helper and may retry according to the retry policy.
	pub async fn first<T: HasHeader + Decode>(&self, mut opts: Options) -> Result<Option<BlockExtrinsic<T>>, Error> {
		opts.filter = opts.filter.or(Some(T::HEADER_INDEX.into()));

		let encoded = self.xt.first(opts).await?;
		let Some(encoded) = encoded else {
			return Ok(None);
		};

		Ok(Some(encoded.as_extrinsic::<T>()?))
	}

	/// Returns the last extrinsic that matches the supplied filters.
	///
	/// # Parameters
	/// - `opts`: Filters describing which extrinsic to fetch.
	///
	/// # Returns
	/// - `Ok(Some(Extrinsic<T>))`: Final matching extrinsic decoded as `T`.
	/// - `Ok(None)`: No extrinsic satisfied the filters.
	/// - `Err(Error)`: The RPC call or payload decoding failed.
	///
	/// # Side Effects
	/// - Performs RPC calls via the encoded-extrinsic helper and may retry according to the retry policy.
	pub async fn last<T: HasHeader + Decode>(&self, mut opts: Options) -> Result<Option<BlockExtrinsic<T>>, Error> {
		opts.filter = opts.filter.or(Some(T::HEADER_INDEX.into()));

		let encoded = self.xt.last(opts).await?;
		let Some(encoded) = encoded else {
			return Ok(None);
		};

		Ok(Some(encoded.as_extrinsic::<T>()?))
	}

	/// Collects every extrinsic that matches the supplied filters.
	///
	/// # Parameters
	/// - `opts`: Filters describing which extrinsics to decode.
	///
	/// # Returns
	/// - `Ok(Vec<Extrinsic<T>>)`: Zero or more matching extrinsics decoded as `T`.
	/// - `Err(Error)`: The RPC call or payload decoding failed.
	///
	/// # Side Effects
	/// - Performs RPC calls via the encoded-extrinsic helper and may retry according to the retry policy.
	pub async fn all<T: HasHeader + Decode>(&self, mut opts: Options) -> Result<Vec<BlockExtrinsic<T>>, Error> {
		opts.filter = opts.filter.or(Some(T::HEADER_INDEX.into()));

		let all = self.xt.all(opts).await?;
		let mut result = Vec::with_capacity(all.len());
		for encoded in all {
			result.push(encoded.as_extrinsic::<T>()?);
		}

		Ok(result)
	}

	/// Counts matching extrinsics without decoding their payloads.
	///
	/// # Parameters
	/// - `opts`: Filters describing which extrinsics to count.
	///
	/// # Returns
	/// - `Ok(usize)`: Number of matching extrinsics.
	/// - `Err(Error)`: The RPC call failed.
	///
	/// # Side Effects
	/// - Performs RPC calls via the encoded-extrinsic helper and may retry according to the retry policy.
	pub async fn count<T: HasHeader>(&self, mut opts: Options) -> Result<usize, Error> {
		opts.filter = Some(T::HEADER_INDEX.into());
		return self.xt.count(opts).await;
	}

	/// Reports whether any extrinsic matches the supplied filters.
	///
	/// # Parameters
	/// - `opts`: Filters describing which extrinsics to test.
	///
	/// # Returns
	/// - `Ok(true)`: At least one matching extrinsic exists.
	/// - `Ok(false)`: No extrinsics matched the filters.
	/// - `Err(Error)`: The RPC call failed.
	///
	/// # Side Effects
	/// - Performs RPC calls via the encoded-extrinsic helper and may retry according to the retry policy.
	pub async fn exists<T: HasHeader>(&self, mut opts: Options) -> Result<bool, Error> {
		opts.filter = Some(T::HEADER_INDEX.into());
		return self.xt.exists(opts).await;
	}

	/// Overrides the retry behaviour for future decoded-extrinsic lookups.
	///
	/// # Parameters
	/// - `value`: `Some(true)` to force retries, `Some(false)` to disable retries, `None` to inherit the client default.
	///
	/// # Returns
	/// - `()`: The override is stored for subsequent operations.
	///
	/// # Side Effects
	/// - Updates the internal retry setting used by follow-up RPC calls.
	pub fn set_retry_on_error(&mut self, value: Option<bool>) {
		self.xt.set_retry_on_error(value);
	}

	/// Reports whether decoded-extrinsic lookups retry after RPC errors.
	///
	/// # Returns
	/// - `true`: Retries are enabled either explicitly or via the client default.
	/// - `false`: Retries are disabled.
	pub fn should_retry_on_error(&self) -> bool {
		self.xt.should_retry_on_error()
	}
}

/// Decoded extrinsic along with metadata and optional signature.
#[derive(Debug, Clone)]
pub struct BlockExtrinsic<T: HasHeader + Decode> {
	/// Optional signature associated with the extrinsic.
	pub signature: Option<ExtrinsicSignature>,
	/// Decoded runtime call payload.
	pub call: T,
	/// Metadata describing where the extrinsic was found.
	pub metadata: BlockExtrinsicMetadata,
}

impl<T: HasHeader + Decode> BlockExtrinsic<T> {
	/// Creates an extrinsic wrapper from decoded data.
	///
	/// # Parameters
	/// - `signature`: Optional signature attached to the extrinsic.
	/// - `call`: Decoded call payload.
	/// - `metadata`: Metadata describing the extrinsic context.
	///
	/// # Returns
	/// - `Self`: Decoded extrinsic wrapper containing the provided data.
	pub fn new(signature: Option<ExtrinsicSignature>, call: T, metadata: BlockExtrinsicMetadata) -> Self {
		Self { signature, call, metadata }
	}

	/// Fetches events emitted by this extrinsic.
	///
	/// # Parameters
	/// - `client`: RPC client used to fetch event data.
	///
	/// # Returns
	/// - `Ok(AllEvents)`: Wrapper containing events for this extrinsic.
	/// - `Err(Error)`: Extrinsic emitted no events or the RPC request failed.
	///
	/// # Side Effects
	/// - Issues RPC requests for event data and may retry according to the client's configuration.
	pub async fn events(&self, client: Client) -> Result<BlockEvents, Error> {
		let events = BlockEventsQuery::new(client, self.metadata.block_id)
			.extrinsic(self.ext_index())
			.await?;

		if events.is_empty() {
			return Err(RpcError::ExpectedData("No events found for extrinsic".into()).into());
		};

		Ok(events)
	}

	/// Returns the index of this extrinsic inside the block.
	///
	/// # Returns
	/// - `u32`: Index of the extrinsic within the block.
	pub fn ext_index(&self) -> u32 {
		self.metadata.ext_index
	}

	/// Returns the extrinsic hash.
	///
	/// # Returns
	/// - `H256`: Hash of the extrinsic.
	pub fn ext_hash(&self) -> H256 {
		self.metadata.ext_hash
	}

	/// Returns the application id if the extrinsic was signed.
	///
	/// # Returns
	/// - `Some(u32)`: Application identifier from the signature.
	/// - `None`: Extrinsic was unsigned.
	pub fn app_id(&self) -> Option<u32> {
		Some(self.signature.as_ref()?.extra.app_id)
	}

	/// Returns the nonce if the extrinsic was signed.
	///
	/// # Returns
	/// - `Some(u32)`: Nonce from the signature.
	/// - `None`: Extrinsic was unsigned.
	pub fn nonce(&self) -> Option<u32> {
		Some(self.signature.as_ref()?.extra.nonce)
	}

	/// Returns the tip if the extrinsic was signed.
	///
	/// # Returns
	/// - `Some(u128)`: Tip reported by the signature.
	/// - `None`: Extrinsic was unsigned.
	pub fn tip(&self) -> Option<u128> {
		Some(self.signature.as_ref()?.extra.tip)
	}

	/// Returns the signer as an ss58 string when available.
	///
	/// # Returns
	/// - `Some(String)`: SS58-encoded signer address.
	/// - `None`: Extrinsic was unsigned or used a non-`Id` multi-address.
	pub fn ss58_address(&self) -> Option<String> {
		match &self.signature.as_ref()?.address {
			MultiAddress::Id(x) => Some(std::format!("{}", x)),
			_ => None,
		}
	}

	/// Converts the extrinsic into a signed variant when a signature is present.
	///
	/// # Returns
	/// - `Ok(SignedExtrinsic<T>)`: Signed wrapper containing the same call and metadata.
	/// - `Err(String)`: Extrinsic was unsigned, so a signed variant cannot be produced.
	pub fn as_signed(self) -> Result<BlockSignedExtrinsic<T>, Error> {
		BlockSignedExtrinsic::<T>::try_from(self).map_err(Error::Other)
	}
}

impl<T: HasHeader + Decode> TryFrom<BlockEncodedExtrinsic> for BlockExtrinsic<T> {
	type Error = String;

	/// Decodes an encoded extrinsic into an `Extrinsic<T>`.
	///
	/// # Parameters
	/// - `value`: Encoded extrinsic containing the SCALE payload.
	///
	/// # Returns
	/// - `Ok(Self)`: Decoded extrinsic with optional signature and metadata.
	/// - `Err(String)`: Payload failed to decode as `T`.
	fn try_from(value: BlockEncodedExtrinsic) -> Result<Self, Self::Error> {
		let call = T::from_call(value.call)?;
		Ok(Self::new(value.signature, call, value.metadata))
	}
}

impl<T: HasHeader + Decode> TryFrom<&BlockEncodedExtrinsic> for BlockExtrinsic<T> {
	type Error = String;

	/// Decodes a borrowed encoded extrinsic into an `Extrinsic<T>`.
	///
	/// # Parameters
	/// - `value`: Borrowed encoded extrinsic containing the SCALE payload.
	///
	/// # Returns
	/// - `Ok(Self)`: Decoded extrinsic with optional signature and cloned metadata.
	/// - `Err(String)`: Payload failed to decode as `T`.
	fn try_from(value: &BlockEncodedExtrinsic) -> Result<Self, Self::Error> {
		let call = T::from_call(&value.call)?;
		Ok(Self::new(value.signature.clone(), call, value.metadata.clone()))
	}
}

#[cfg(test)]
pub mod tests {
	use super::*;
	use crate::TURING_ENDPOINT;
	use avail_rust_core::avail::{
		balances::tx::TransferAllowDeath, data_availability::tx::SubmitData, timestamp::tx::Set,
		vector::tx::FailedSendMessageTxs,
	};

	fn match_timestamp(ext: &BlockExtrinsic<Set>) {
		assert_eq!(
			std::format!("{:?}", ext.ext_hash()),
			"0xdbfa60611f72a714100338db1c7b11c66636a76f116b214d879de069afe67a74"
		);
		assert_eq!(ext.ext_index(), 0);
		assert_eq!(ext.nonce(), None);
		assert!(ext.signature.is_none());
		assert!(ext.app_id().is_none());
		assert_eq!(ext.call.now, 1761567760000);
	}

	fn match_failed_send_message(ext: &BlockExtrinsic<FailedSendMessageTxs>) {
		assert_eq!(
			std::format!("{:?}", ext.ext_hash()),
			"0x92cdb77314063a01930b093516d19a453399710cc8ae635ff5ab6cf76b26f218"
		);
		assert_eq!(ext.ext_index(), 3);
		assert_eq!(ext.nonce(), None);
		assert!(ext.signature.is_none());
		assert!(ext.app_id().is_none());
		assert_eq!(ext.call.failed_txs.len(), 0);
	}

	fn match_submit_data_1(ext: &BlockExtrinsic<SubmitData>) {
		assert_eq!(
			std::format!("{:?}", ext.ext_hash()),
			"0x8b84294cba5f2b88e2887ac999ebac3806af7be9cca2a521fc889421f240f3ef"
		);
		assert_eq!(ext.ext_index(), 1);
		assert_eq!(ext.nonce(), Some(30));
		assert!(ext.signature.is_some());
		assert_eq!(ext.app_id(), Some(1));
		assert_eq!(ext.ss58_address(), Some("5Ev2jfLbYH6ENZ8ThTmqBX58zoinvHyqvRMvtoiUnLLcv1NJ".to_string()));
		assert_eq!(String::from_utf8(ext.call.data.clone()).unwrap(), "AABBCC");
	}

	fn match_submit_data_2(ext: &BlockExtrinsic<SubmitData>) {
		assert_eq!(
			std::format!("{:?}", ext.ext_hash()),
			"0x19fab0492322016c644af12f1547c587ef51edd10311db85cb3aa2680f6ae4ba"
		);
		assert_eq!(ext.ext_index(), 2);
		assert_eq!(ext.nonce(), Some(4));
		assert!(ext.signature.is_some());
		assert_eq!(ext.app_id(), Some(2));
		assert_eq!(ext.ss58_address(), Some("5DPDXCcqk1YNVZ3M9s9iwJnr9XAVfTxf8hNa4LS51fjHKAzk".to_string()));
		assert_eq!(String::from_utf8(ext.call.data.clone()).unwrap(), "CCBBAA");
	}

	#[tokio::test]
	async fn query_get_test() {
		let client = Client::new(TURING_ENDPOINT).await.unwrap();
		let query = client.block(2491314).extrinsics();

		let ext = query.get::<Set>(0).await.unwrap().unwrap();
		match_timestamp(&ext);

		let ext = query.get::<SubmitData>(1).await.unwrap().unwrap();
		match_submit_data_1(&ext);

		let ext = query.get::<SubmitData>(2).await.unwrap().unwrap();
		match_submit_data_2(&ext);

		let ext = query.get::<FailedSendMessageTxs>(3).await.unwrap().unwrap();
		match_failed_send_message(&ext);

		// Wrong type
		assert!(query.get::<FailedSendMessageTxs>(2).await.is_err());

		// Non Existing
		assert!(query.get::<FailedSendMessageTxs>(4).await.unwrap().is_none());
	}

	#[tokio::test]
	async fn query_first_test() {
		let client = Client::new(TURING_ENDPOINT).await.unwrap();
		let query = client.block(2491314).extrinsics();

		// App Id 1
		let opts = Options::new().app_id(1);
		let ext = query.first(opts).await.unwrap().unwrap();
		match_submit_data_1(&ext);

		// App Id 2
		let opts = Options::new().app_id(2);
		let ext = query.first(opts).await.unwrap().unwrap();
		match_submit_data_2(&ext);

		// Nonce 30
		let opts = Options::new().nonce(30);
		let ext = query.first(opts).await.unwrap().unwrap();
		match_submit_data_1(&ext);

		// Nonce 4
		let opts = Options::new().nonce(4);
		let ext = query.first(opts).await.unwrap().unwrap();
		match_submit_data_2(&ext);

		// DA call
		let opts = Options::new().filter(SubmitData::HEADER_INDEX);
		let ext = query.first(opts).await.unwrap().unwrap();
		match_submit_data_1(&ext);

		// Pall Call
		let opts = Options::new().filter(SubmitData::HEADER_INDEX.0);
		let ext = query.first(opts).await.unwrap().unwrap();
		match_submit_data_1(&ext);

		// Nothing
		let ext = query.first::<Set>(Default::default()).await.unwrap().unwrap();
		match_timestamp(&ext);

		// Wrong Type
		let opts = Options::new().filter(1u32);
		assert!(query.first::<Set>(opts).await.is_err());

		// Non Existing
		let opts = Options::new().filter(100u32);
		assert!(query.first::<Set>(opts).await.unwrap().is_none());
	}

	#[tokio::test]
	async fn query_last_test() {
		let client = Client::new(TURING_ENDPOINT).await.unwrap();
		let query = client.block(2491314).extrinsics();

		// App Id 1
		let opts = Options::new().app_id(1);
		let ext = query.last(opts).await.unwrap().unwrap();
		match_submit_data_1(&ext);

		// App Id 2
		let opts = Options::new().app_id(2);
		let ext = query.last(opts).await.unwrap().unwrap();
		match_submit_data_2(&ext);

		// Nonce 30
		let opts = Options::new().nonce(30);
		let ext = query.last(opts).await.unwrap().unwrap();
		match_submit_data_1(&ext);

		// Nonce 4
		let opts = Options::new().nonce(4);
		let ext = query.last(opts).await.unwrap().unwrap();
		match_submit_data_2(&ext);

		// DA call
		let opts = Options::new().filter(SubmitData::HEADER_INDEX);
		let ext = query.last(opts).await.unwrap().unwrap();
		match_submit_data_2(&ext);

		// Pall Call
		let opts = Options::new().filter(SubmitData::HEADER_INDEX.0);
		let ext = query.last(opts).await.unwrap().unwrap();
		match_submit_data_2(&ext);

		// Nothing
		let ext = query.last(Default::default()).await.unwrap().unwrap();
		match_failed_send_message(&ext);

		// Wrong Type
		let opts = Options::new().filter(1u32);
		assert!(query.last::<Set>(opts).await.is_err());

		// Non Existing
		let opts = Options::new().filter(100u32);
		assert!(query.last::<Set>(opts).await.unwrap().is_none());
	}

	#[tokio::test]
	async fn query_all_test() {
		let client = Client::new(TURING_ENDPOINT).await.unwrap();
		let query = client.block(2491314).extrinsics();

		// App Id 1
		let opts = Options::new().app_id(1);
		let ext = query.all(opts).await.unwrap();
		match_submit_data_1(&ext[0]);

		// App Id 2
		let opts = Options::new().app_id(2);
		let ext = query.all(opts).await.unwrap();
		match_submit_data_2(&ext[0]);
		assert_eq!(ext.len(), 1);

		// Nonce 30
		let opts = Options::new().nonce(30);
		let ext = query.all(opts).await.unwrap();
		match_submit_data_1(&ext[0]);
		assert_eq!(ext.len(), 1);

		// Nonce 4
		let opts = Options::new().nonce(4);
		let ext = query.all(opts).await.unwrap();
		match_submit_data_2(&ext[0]);
		assert_eq!(ext.len(), 1);

		// DA call
		let opts = Options::new().filter(SubmitData::HEADER_INDEX);
		let ext = query.all(opts).await.unwrap();
		match_submit_data_1(&ext[0]);
		match_submit_data_2(&ext[1]);
		assert_eq!(ext.len(), 2);

		// Pall Call
		let opts = Options::new().filter(SubmitData::HEADER_INDEX.0);
		let ext = query.all(opts).await.unwrap();
		match_submit_data_1(&ext[0]);
		match_submit_data_2(&ext[1]);
		assert_eq!(ext.len(), 2);

		// Nothing
		let ext = query.all::<SubmitData>(Default::default()).await.unwrap();
		match_submit_data_1(&ext[0]);
		match_submit_data_2(&ext[1]);
		assert_eq!(ext.len(), 2);

		let ext = query.all::<Set>(Default::default()).await.unwrap();
		match_timestamp(&ext[0]);
		assert_eq!(ext.len(), 1);

		let ext = query.all::<FailedSendMessageTxs>(Default::default()).await.unwrap();
		match_failed_send_message(&ext[0]);
		assert_eq!(ext.len(), 1);

		// Non Decodable
		let opts = Options::new().filter(1u32);
		assert!(query.all::<Set>(opts).await.is_err());

		// Non Existing
		let opts = Options::new().filter(100u32);
		let ext = query.all::<Set>(opts).await.unwrap();
		assert_eq!(ext.len(), 0)
	}

	#[tokio::test]
	async fn query_count_test() {
		let client = Client::new(TURING_ENDPOINT).await.unwrap();
		let query = client.block(2491314).extrinsics();

		// App Id 1
		let opts = Options::new().app_id(1);
		assert_eq!(query.count::<SubmitData>(opts).await.unwrap(), 1);

		// App Id 2
		let opts = Options::new().app_id(2);
		assert_eq!(query.count::<SubmitData>(opts).await.unwrap(), 1);

		// Nonce 30
		let opts = Options::new().nonce(30);
		assert_eq!(query.count::<SubmitData>(opts).await.unwrap(), 1);

		// Nonce 4
		let opts = Options::new().nonce(4);
		assert_eq!(query.count::<SubmitData>(opts).await.unwrap(), 1);

		// DA call
		assert_eq!(query.count::<SubmitData>(Default::default()).await.unwrap(), 2);

		// DA call
		assert_eq!(query.count::<Set>(Default::default()).await.unwrap(), 1);

		// Non Existing
		assert_eq!(query.count::<TransferAllowDeath>(Default::default()).await.unwrap(), 0);
	}

	#[tokio::test]
	async fn query_exists_test() {
		let client = Client::new(TURING_ENDPOINT).await.unwrap();
		let query = client.block(2491314).extrinsics();

		// App Id 1
		let opts = Options::new().app_id(1);
		assert_eq!(query.exists::<SubmitData>(opts).await.unwrap(), true);

		// App Id 2
		let opts = Options::new().app_id(2);
		assert_eq!(query.exists::<SubmitData>(opts).await.unwrap(), true);

		// Nonce 30
		let opts = Options::new().nonce(30);
		assert_eq!(query.exists::<SubmitData>(opts).await.unwrap(), true);

		// Nonce 4
		let opts = Options::new().nonce(4);
		assert_eq!(query.exists::<SubmitData>(opts).await.unwrap(), true);

		// DA call
		assert_eq!(query.exists::<SubmitData>(Default::default()).await.unwrap(), true);

		// Nothing
		assert_eq!(query.exists::<Set>(Default::default()).await.unwrap(), true);

		// Non Existing
		assert_eq!(query.exists::<TransferAllowDeath>(Default::default()).await.unwrap(), false);
	}
}