Replace BATCH_CALL_SUPPORTED (#1733)

* Simplify submit_and_watch_signed_extrinsic

The way submit_and_watch_signed_extrinsic is used now, we can always
derive the SignParam from other params. If in the future we need more
customization possibilities, we can define a new method.

* Simplify submit_signed_extrinsic

* Send maybe_batch_tx as a parameter

Send `maybe_batch_tx` as a parameter to `submit_proof()`. This way we
can deduplicate the logic that submits the extrinsic for
`messages_source and `messages_target` and we can simplify the logic in
the race loop a bit.

* Define BatchProofTransaction

Deduplicate BatchConfirmationTransaction and BatchDeliveryTransaction by
replacing both of them with BatchProofTransaction

* Define ChainWithUtilityPallet and BatchCallBuilderConstructor

- Define `ChainWithUtilityPallet` in order to be able to associate the
  batching functionality with chains
- Defining `BatchCallBuilderConstructor` in order to have a more reliable
  way of checking whether an end of a messages pipeline supports batching
  or no. `BatchCallBuilderConstructor::new_builder()` returns an
  `Option<BatchCallBuilder>`.This is a bit safer because each time a caller
  tries to start creating a batch call, it will call `new_builder()` and
  will be required to handle the returned `Option`. Before we only had a
  bool `BATCH_CALL_SUPPORTED` the caller could have forgetten to check.

bridges/relays/lib-substrate-relay/src/finality/initialize.rs

@@ -22,9 +22,11 @@
 //! with this header.
 
 use crate::{error::Error, finality::engine::Engine};
+use sp_core::Pair;
 
 use relay_substrate_client::{
-	Chain, ChainWithTransactions, Client, Error as SubstrateError, SignParam, UnsignedTransaction,
+	AccountKeyPairOf, Chain, ChainWithTransactions, Client, Error as SubstrateError,
+	UnsignedTransaction,
 };
 use sp_runtime::traits::Header as HeaderT;
 
@@ -37,8 +39,7 @@ pub async fn initialize<
 >(
 	source_client: Client<SourceChain>,
 	target_client: Client<TargetChain>,
-	target_transactions_signer: TargetChain::AccountId,
-	target_signing_data: SignParam<TargetChain>,
+	target_signer: AccountKeyPairOf<TargetChain>,
 	prepare_initialize_transaction: F,
 	dry_run: bool,
 ) where
@@ -48,12 +49,12 @@ pub async fn initialize<
 		) -> Result<UnsignedTransaction<TargetChain>, SubstrateError>
 		+ Send
 		+ 'static,
+	TargetChain::AccountId: From<<TargetChain::AccountKeyPair as Pair>::Public>,
 {
 	let result = do_initialize::<E, _, _, _>(
 		source_client,
 		target_client,
-		target_transactions_signer,
-		target_signing_data,
+		target_signer,
 		prepare_initialize_transaction,
 		dry_run,
 	)
@@ -87,8 +88,7 @@ async fn do_initialize<
 >(
 	source_client: Client<SourceChain>,
 	target_client: Client<TargetChain>,
-	target_transactions_signer: TargetChain::AccountId,
-	target_signing_data: SignParam<TargetChain>,
+	target_signer: AccountKeyPairOf<TargetChain>,
 	prepare_initialize_transaction: F,
 	dry_run: bool,
 ) -> Result<
@@ -102,6 +102,7 @@ where
 		) -> Result<UnsignedTransaction<TargetChain>, SubstrateError>
 		+ Send
 		+ 'static,
+	TargetChain::AccountId: From<<TargetChain::AccountKeyPair as Pair>::Public>,
 {
 	let is_initialized = E::is_initialized(&target_client)
 		.await
@@ -128,20 +129,16 @@ where
 	);
 
 	let initialization_tx_hash = target_client
-		.submit_signed_extrinsic(
-			target_transactions_signer,
-			target_signing_data,
-			move |_, transaction_nonce| {
-				let tx = prepare_initialize_transaction(transaction_nonce, initialization_data);
-				if dry_run {
-					Err(SubstrateError::Custom(
-						"Not submitting extrinsic in `dry-run` mode!".to_string(),
-					))
-				} else {
-					tx
-				}
-			},
-		)
+		.submit_signed_extrinsic(&target_signer, move |_, transaction_nonce| {
+			let tx = prepare_initialize_transaction(transaction_nonce, initialization_data);
+			if dry_run {
+				Err(SubstrateError::Custom(
+					"Not submitting extrinsic in `dry-run` mode!".to_string(),
+				))
+			} else {
+				tx
+			}
+		})
 		.await
 		.map_err(|err| Error::SubmitTransaction(TargetChain::NAME, err))?;
 

bridges/relays/lib-substrate-relay/src/finality/target.rs

@@ -27,8 +27,8 @@ use crate::{
 use async_trait::async_trait;
 use finality_relay::TargetClient;
 use relay_substrate_client::{
-	AccountIdOf, AccountKeyPairOf, Chain, Client, Error, HeaderIdOf, HeaderOf, SignParam,
-	SyncHeader, TransactionEra, TransactionTracker, UnsignedTransaction,
+	AccountIdOf, AccountKeyPairOf, Chain, Client, Error, HeaderIdOf, HeaderOf, SyncHeader,
+	TransactionEra, TransactionTracker, UnsignedTransaction,
 };
 use relay_utils::relay_loop::Client as RelayClient;
 use sp_core::Pair;
@@ -111,20 +111,12 @@ where
 		header: SyncHeader<HeaderOf<P::SourceChain>>,
 		proof: SubstrateFinalityProof<P>,
 	) -> Result<Self::TransactionTracker, Error> {
-		let genesis_hash = *self.client.genesis_hash();
 		let transaction_params = self.transaction_params.clone();
 		let call =
 			P::SubmitFinalityProofCallBuilder::build_submit_finality_proof_call(header, proof);
-		let (spec_version, transaction_version) = self.client.simple_runtime_version().await?;
 		self.client
 			.submit_and_watch_signed_extrinsic(
-				self.transaction_params.signer.public().into(),
-				SignParam::<P::TargetChain> {
-					spec_version,
-					transaction_version,
-					genesis_hash,
-					signer: transaction_params.signer.clone(),
-				},
+				&self.transaction_params.signer,
 				move |best_block_id, transaction_nonce| {
 					Ok(UnsignedTransaction::new(call.into(), transaction_nonce)
 						.era(TransactionEra::new(best_block_id, transaction_params.mortality)))