bump zombienet-sdk and subxt versions (#9587)

Replace #9506

---------

Co-authored-by: Bastian Köcher <[email protected]>
Co-authored-by: Bastian Köcher <[email protected]>

Author: 2 people

Cargo.toml

@@ -1404,9 +1404,9 @@ substrate-test-runtime-client = { path = "substrate/test-utils/runtime/client" }
 substrate-test-runtime-transaction-pool = { path = "substrate/test-utils/runtime/transaction-pool" }
 substrate-test-utils = { path = "substrate/test-utils" }
 substrate-wasm-builder = { path = "substrate/utils/wasm-builder", default-features = false }
-subxt = { version = "0.41", default-features = false }
-subxt-metadata = { version = "0.41", default-features = false }
-subxt-signer = { version = "0.41" }
+subxt = { version = "0.43", default-features = false }
+subxt-metadata = { version = "0.43", default-features = false }
+subxt-signer = { version = "0.43" }
 syn = { version = "2.0.87" }
 sysinfo = { version = "0.30" }
 tar = { version = "0.4" }
@@ -1480,9 +1480,9 @@ xcm-runtime-apis = { path = "polkadot/xcm/xcm-runtime-apis", default-features =
 xcm-simulator = { path = "polkadot/xcm/xcm-simulator", default-features = false }
 yet-another-parachain-runtime = { path = "cumulus/parachains/runtimes/testing/yet-another-parachain" }
 zeroize = { version = "1.7.0", default-features = false }
-zombienet-configuration = { version = "0.3.6" }
-zombienet-orchestrator = { version = "0.3.6" }
-zombienet-sdk = { version = "0.3.6" }
+zombienet-configuration = { version = "0.3.12" }
+zombienet-orchestrator = { version = "0.3.12" }
+zombienet-sdk = { version = "0.3.12" }
 zstd = { version = "0.12.4", default-features = false }
 
 [profile.release]

cumulus/zombienet/zombienet-sdk-helpers/src/lib.rs

@@ -16,8 +16,15 @@ use tokio::{
 	time::{sleep, Duration},
 };
 use zombienet_sdk::subxt::{
-	blocks::Block, config::substrate::DigestItem, events::Events, ext::scale_value::value,
-	tx::DynamicPayload, utils::H256, OnlineClient, PolkadotConfig,
+	self,
+	blocks::Block,
+	config::{polkadot::PolkadotExtrinsicParamsBuilder, substrate::DigestItem},
+	dynamic::Value,
+	events::Events,
+	ext::scale_value::value,
+	tx::{signer::Signer, DynamicPayload, TxStatus},
+	utils::H256,
+	OnlineClient, PolkadotConfig,
 };
 
 // Maximum number of blocks to wait for a session change.
@@ -394,3 +401,109 @@ fn extract_relay_parent_storage_root(
 		_ => None,
 	}
 }
+
+/// Submits the given `call` as transaction and waits for it successful finalization.
+///
+/// The transaction is send as immortal transaction.
+pub async fn submit_extrinsic_and_wait_for_finalization_success<S: Signer<PolkadotConfig>>(
+	client: &OnlineClient<PolkadotConfig>,
+	call: &DynamicPayload,
+	signer: &S,
+) -> Result<(), anyhow::Error> {
+	let extensions = PolkadotExtrinsicParamsBuilder::new().immortal().build();
+
+	let mut tx = client
+		.tx()
+		.create_signed(call, signer, extensions)
+		.await?
+		.submit_and_watch()
+		.await?;
+
+	// Below we use the low level API to replicate the `wait_for_in_block` behaviour
+	// which was removed in subxt 0.33.0. See https://github.com/paritytech/subxt/pull/1237.
+	while let Some(status) = tx.next().await {
+		let status = status?;
+		match &status {
+			TxStatus::InBestBlock(tx_in_block) | TxStatus::InFinalizedBlock(tx_in_block) => {
+				let _result = tx_in_block.wait_for_success().await?;
+				let block_status =
+					if status.as_finalized().is_some() { "Finalized" } else { "Best" };
+				log::info!("[{}] In block: {:#?}", block_status, tx_in_block.block_hash());
+			},
+			TxStatus::Error { message } |
+			TxStatus::Invalid { message } |
+			TxStatus::Dropped { message } => {
+				return Err(anyhow::format_err!("Error submitting tx: {message}"));
+			},
+			_ => continue,
+		}
+	}
+	Ok(())
+}
+
+/// Submits the given `call` as transaction and waits `timeout_secs` for it successful finalization.
+///
+/// If the transaction does not reach the finalized state in `timeout_secs` an error is returned.
+/// The transaction is send as immortal transaction.
+pub async fn submit_extrinsic_and_wait_for_finalization_success_with_timeout<
+	S: Signer<PolkadotConfig>,
+>(
+	client: &OnlineClient<PolkadotConfig>,
+	call: &DynamicPayload,
+	signer: &S,
+	timeout_secs: impl Into<u64>,
+) -> Result<(), anyhow::Error> {
+	let secs = timeout_secs.into();
+	let res = tokio::time::timeout(
+		Duration::from_secs(secs),
+		submit_extrinsic_and_wait_for_finalization_success(client, call, signer),
+	)
+	.await;
+
+	match res {
+		Ok(Ok(_)) => Ok(()),
+		Ok(Err(e)) => Err(anyhow!("Error waiting for metric: {}", e)),
+		// timeout
+		Err(_) => Err(anyhow!("Timeout ({secs}), waiting for extrinsic finalization")),
+	}
+}
+
+/// Asserts that the given `para_id` is registered at the relay chain.
+pub async fn assert_para_is_registered(
+	relay_client: &OnlineClient<PolkadotConfig>,
+	para_id: ParaId,
+	blocks_to_wait: u32,
+) -> Result<(), anyhow::Error> {
+	let mut blocks_sub = relay_client.blocks().subscribe_all().await?;
+	let para_id: u32 = para_id.into();
+
+	let keys: Vec<Value> = vec![];
+	let query = subxt::dynamic::storage("Paras", "Parachains", keys);
+
+	let mut blocks_cnt = 0;
+	while let Some(block) = blocks_sub.next().await {
+		let block = block?;
+		log::debug!("Relay block #{}, checking if para_id {para_id} is registered", block.number(),);
+		let parachains = block.storage().fetch(&query).await?;
+
+		let parachains: Vec<u32> = match parachains {
+			Some(parachains) => parachains.as_type()?,
+			None => vec![],
+		};
+
+		log::debug!("Registered para_ids: {:?}", parachains);
+
+		if parachains.iter().any(|p| para_id.eq(p)) {
+			log::debug!("para_id {para_id} registered");
+			return Ok(());
+		}
+		if blocks_cnt >= blocks_to_wait {
+			return Err(anyhow!(
+				"Parachain {para_id} not registered within {blocks_to_wait} blocks"
+			));
+		}
+		blocks_cnt += 1;
+	}
+
+	Err(anyhow!("No more blocks to check"))
+}

cumulus/zombienet/zombienet-sdk/tests/statement_store/mod.rs

@@ -8,7 +8,8 @@ use anyhow::anyhow;
 use sp_core::{Bytes, Encode};
 use zombienet_sdk::{
 	subxt::{
-		backend::rpc::RpcClient, rpc_params, utils::url_is_secure, OnlineClient, PolkadotConfig,
+		backend::rpc::RpcClient, ext::subxt_rpcs::rpc_params, utils::url_is_secure, OnlineClient,
+		PolkadotConfig,
 	},
 	NetworkConfigBuilder,
 };

polkadot/zombienet-sdk-tests/Cargo.toml

@@ -17,7 +17,7 @@ polkadot-primitives.default-features = true
 polkadot-primitives.workspace = true
 serde = { workspace = true }
 serde_json = { workspace = true }
-subxt = { version = "0.38.1", default-features = false }
+subxt = { workspace = true, default-features = false }
 tokio = { workspace = true, features = ["rt-multi-thread"] }
 tokio-util = { workspace = true, features = ["time"] }
 zombienet-orchestrator = { workspace = true }

polkadot/zombienet-sdk-tests/tests/disabling/slashing.rs

@@ -6,6 +6,7 @@
 //! making some of the honest nodes go offline.
 
 use anyhow::anyhow;
+use codec::Decode;
 use cumulus_zombienet_sdk_helpers::{
 	assert_blocks_are_being_finalized, assert_finalized_para_throughput,
 	wait_for_first_session_change,
@@ -111,14 +112,13 @@ async fn dispute_past_session_slashing() -> Result<(), anyhow::Error> {
 	while let Some(block) = best_blocks.next().await {
 		// NOTE: we can't use `at_latest` here, because it will utilize latest *finalized* block
 		// and finality is stalled...
-		let disputes = relay_client
-			.runtime_api()
-			.at(block?.hash())
-			.call_raw::<Vec<(SessionIndex, CandidateHash, DisputeState<BlockNumber>)>>(
-				"ParachainHost_disputes",
-				None,
-			)
-			.await?;
+		let disputes = Vec::<(SessionIndex, CandidateHash, DisputeState<BlockNumber>)>::decode(
+			&mut &relay_client
+				.runtime_api()
+				.at(block?.hash())
+				.call_raw("ParachainHost_disputes", None)
+				.await?[..],
+		)?;
 		if let Some((session, _, _)) = disputes.first() {
 			dispute_session = *session;
 			break;

polkadot/zombienet-sdk-tests/tests/elastic_scaling/doesnt_break_parachains.rs

@@ -5,6 +5,7 @@
 // itself if ElasticScalingMVP feature is enabled in genesis.
 
 use anyhow::anyhow;
+use codec::Decode;
 use cumulus_zombienet_sdk_helpers::{
 	assert_finality_lag, assert_finalized_para_throughput, create_assign_core_call,
 };
@@ -94,12 +95,14 @@ async fn doesnt_break_parachains_test() -> Result<(), anyhow::Error> {
 	assert_finality_lag(&para_client, 6).await?;
 
 	// Sanity check that indeed the parachain has two assigned cores.
-	let cq = relay_client
-		.runtime_api()
-		.at_latest()
-		.await?
-		.call_raw::<BTreeMap<CoreIndex, VecDeque<ParaId>>>("ParachainHost_claim_queue", None)
-		.await?;
+	let cq = BTreeMap::<CoreIndex, VecDeque<ParaId>>::decode(
+		&mut &relay_client
+			.runtime_api()
+			.at_latest()
+			.await?
+			.call_raw("ParachainHost_claim_queue", None)
+			.await?[..],
+	)?;
 
 	assert_eq!(
 		cq,