initail configuration

Author: MrishoLukamba

parachain/simtests/src/pallet_mmr.rs

@@ -3,7 +3,6 @@
 use std::{env, time::Duration};
 
 use codec::Decode;
-use ismp::host::ethereum;
 use merkle_mountain_range::MerkleProof;
 use sc_consensus_manual_seal::CreatedBlock;
 use sp_core::{crypto::Ss58Codec, keccak_256, offchain::StorageKind, Bytes, H256};
@@ -14,14 +13,31 @@ use sp_mmr_primitives::{
 	INDEXING_PREFIX,
 };
 use sp_runtime::traits::Keccak256;
-use subxt::{rpc_params, tx::SubmittableExtrinsic, utils::H160};
+use subxt::{
+	rpc_params,
+	tx::SubmittableExtrinsic,
+	utils::{AccountId32, H160},
+	OnlineClient,
+};
 
+use ismp::host::StateMachine;
 use mmr_primitives::{DataOrHash, FullLeaf};
 use pallet_ismp::mmr::{Leaf, ProofKeys};
 use pallet_mmr::mmr::Hasher as MmrHasher;
+use subxt_signer::sr25519::dev::{self};
 use subxt_utils::{
-	gargantua, gargantua::api::runtime_types::pallet_ismp_demo::pallet::EvmParams, Hyperbridge,
+	gargantua,
+	gargantua::api::runtime_types::{
+		ismp::host::Ethereum,
+		pallet_ismp_demo::pallet::{EvmParams, GetRequest, TransferParams},
+	},
+	Hyperbridge,
 };
+use tesseract_integration_test;
+use tesseract_substrate::{self, SubstrateClient};
+
+const LEAVES_DEPTH: u32 = 630_000; // leaves = approx 1Gb
+const PRUNING_DEPTH: u32 = 63_000; // leaves = approx 100 Mb
 
 #[tokio::test]
 #[ignore]
@@ -41,13 +57,13 @@ async fn test_insert_1_billion_mmr_leaves() -> Result<(), anyhow::Error> {
 		&format!("ws://127.0.0.1:{}", port),
 		u32::MAX,
 	)
-	.await?;
+		.await?;
 	let pb = ProgressBar::new(100_000);
 	for pos in 44_243..100_000 {
 		// Initialize MMR Pallet by dispatching some leaves and finalizing
 		let params = EvmParams {
 			module: H160::random(),
-			destination: ethereum::EXECUTION_LAYER,
+			destination: Ethereum::ExecutionLayer,
 			timeout: 0,
 			count: 10_000,
 		};
@@ -95,7 +111,7 @@ async fn dispatch_requests() -> Result<(), anyhow::Error> {
 		&format!("ws://127.0.0.1:{}", port),
 		u32::MAX,
 	)
-	.await?;
+		.await?;
 
 	let address = subxt_utils::gargantua::api::storage().mmr().number_of_leaves();
 	let leaf_count_at_start = client
@@ -117,7 +133,7 @@ async fn dispatch_requests() -> Result<(), anyhow::Error> {
 	// Initialize MMR Pallet by dispatching some leaves and finalizing
 	let params = EvmParams {
 		module: H160::random(),
-		destination: ethereum::EXECUTION_LAYER,
+		destination: Ethereum::ExecutionLayer,
 		timeout: 0,
 		count: 10,
 	};
@@ -194,7 +210,7 @@ async fn dispatch_requests() -> Result<(), anyhow::Error> {
 		for _ in 0..3 {
 			let params = EvmParams {
 				module: H160::random(),
-				destination: ethereum::EXECUTION_LAYER,
+				destination: Ethereum::ExecutionLayer,
 				timeout: 0,
 				count: 10,
 			};
@@ -255,7 +271,7 @@ async fn dispatch_requests() -> Result<(), anyhow::Error> {
 		for i in 0..accounts.len() {
 			let params = EvmParams {
 				module: H160::random(),
-				destination: ethereum::ARBITRUM,
+				destination: Ethereum::Arbitrum,
 				timeout: 0,
 				count: 10,
 			};
@@ -447,3 +463,111 @@ async fn dispatch_requests() -> Result<(), anyhow::Error> {
 	assert!(res);
 	Ok(())
 }
+
+/// offchainDB mmr prunning for timedout request and processed requests that knowledge of their
+/// internal nodes is of no use for relayers and users.
+/// Prunning should be triggered iff a certain depth has been reached,
+/// depth = current_number_of_leaves - last_number_of_leaves
+/// This logic should make/enforce somehow maximum storage of requests
+///
+/// Pruning should not consume any useful blockweight hence should be done during on-idle.
+//#[cfg(feature = "offchainDb-pruning")]
+#[tokio::test(flavor = "multi_thread")]
+#[ignore]
+async fn offchainDb_mmr_pruning_requests_work() -> Result<(), anyhow::Error> {
+	let (chain_a_sub_client, chain_b_sub_client) = tesseract_integration_test::create_clients()?;
+	// produce some initial blocks on both chains ( A and B )
+	for _ in 0..=10 {
+		let block = chain_a_sub_client
+			.client
+			.rpc()
+			.request::<CreatedBlock<H256>>("engine_createBlock", rpc_params![true, false])
+			.await?;
+
+		let finalized = chain_a_sub_client
+			.client
+			.rpc()
+			.request::<bool>("engine_finalizeBlock", rpc_params![block.hash])
+			.await?;
+		assert!(finalized);
+
+		let block = chain_b_sub_client
+			.client
+			.rpc()
+			.request::<CreatedBlock<H256>>("engine_createBlock", rpc_params![true, false])
+			.await?;
+
+		let finalized = chain_b_sub_client
+			.client
+			.rpc()
+			.request::<bool>("engine_finalizeBlock", rpc_params![block.hash])
+			.await?;
+		assert!(finalized);
+	}
+	tokio::time::sleep(Duration::from_secs(10)).await;
+
+	// dispatch and process 600_000 request
+	dispatch_and_process_requests(chain_a_sub_client.clone(), chain_b_sub_client.clone(), 600_000)
+		.await?;
+	// assert number of leaves
+	let leaves_count = chain_a_sub_client
+		.client
+		.storage()
+		.at_latest()
+		.await?
+		.fetch(&gargantua::api::storage().mmr().number_of_leaves())
+		.await?
+		.ok_or("Failed to fetch")
+		.unwrap();
+
+	assert_eq!(leaves_count, 600_000);
+	// perform random lookup in the offchain Db
+
+	// dispatch and process additional 30_000 request to trigger prunning
+	dispatch_and_process_requests(chain_a_sub_client.clone(), chain_b_sub_client.clone(), 30_000)
+		.await?;
+
+	// assert the number of leaves are not 630_000
+
+	// get the number of leaves remaining (A)
+
+	dispatch_and_process_requests(chain_a_sub_client, chain_b_sub_client, 100_000).await?;
+
+	// assert the number of leaves are A + 100_000 indicating not pruned as the depth not reached
+
+	Ok(())
+}
+
+/// dispatch get and post requests and timeout post request and process get_requests
+/// this function should return no of timedout and pruned requests
+async fn dispatch_and_process_requests(
+	client_a_sub: SubstrateClient<Hyperbridge>,
+	client_b_sub: SubstrateClient<Hyperbridge>,
+	count: u64,
+) -> Result<u64, anyhow::Error> {
+	// post request
+	let amount: u128 = 100 * 1000000000000;
+	let transfer_params = TransferParams {
+		to: AccountId32(dev::alice().public_key().0),
+		amount,
+		para_id: 2001,
+		timeout: 5,
+	};
+
+	// get request
+	let encoded_chain_b_id_storage_key =
+		"0x0d715f2646c8f85767b5d2764bb2782604a74d81251e398fd8a0a4d55023bb3f";
+
+	let latest_height_b =
+		client_a_sub.query_latest_height(client_b_sub.state_machine_id()).await? - 1;
+	let get_params = GetRequest {
+		para_id: 2001,
+		height: latest_height_b,
+		timeout: 0,
+		keys: vec![hex::decode(encoded_chain_b_id_storage_key.strip_prefix("0x").unwrap()).unwrap()],
+	};
+
+	// batch submit the requests based on number of counts
+	todo!();
+	Ok(0)
+}