statement-store: implement new rpc api

cumulus/parachains/runtimes/people/people-westend/src/lib.rs

@@ -1152,8 +1152,10 @@ impl_runtime_apis! {
 			_source: StatementSource,
 			statement: Statement,
 		) -> Result<ValidStatement, InvalidStatement> {
-			let account = match statement.verify_signature() {
-				SignatureVerificationResult::Valid(account) => account.into(),
+			match statement.verify_signature() {
+				SignatureVerificationResult::Valid(account) => {
+					tracing::debug!(target: "runtime", "Valid statement signature from account: {:?}", account);
+				},
 				SignatureVerificationResult::Invalid => {
 					tracing::debug!(target: "runtime", "Bad statement signature.");
 					return Err(InvalidStatement::BadProof)
@@ -1164,19 +1166,14 @@ impl_runtime_apis! {
 				},
 			};
 
-			// For now just allow validators to store some statements.
+			// For now just allow a small quota to everyone to help with testing.
+			// Later we will have more sophisticated checks here.
 			// In the future we will allow people.
-			if pallet_session::Validators::<Runtime>::get().contains(&account) {
-				Ok(ValidStatement {
-					max_count: 2,
-					max_size: 1024,
-				})
-			} else {
-				Ok(ValidStatement {
-					max_count: 0,
-					max_size: 0,
-				})
-			}
+			Ok(ValidStatement {
+				max_count: 2 * 1024,
+				max_size: 1024 * 10,
+			})
+
 		}
 	}
 }

cumulus/polkadot-omni-node/lib/src/common/rpc.rs

@@ -41,6 +41,7 @@ pub(crate) trait BuildRpcExtensions<Client, Backend, Pool, StatementStore> {
 		backend: Arc<Backend>,
 		pool: Arc<Pool>,
 		statement_store: Option<Arc<StatementStore>>,
+		spawn_handle: Arc<dyn sp_core::traits::SpawnNamed>,
 	) -> sc_service::error::Result<RpcExtension>;
 }
 
@@ -66,6 +67,7 @@ where
 			sc_transaction_pool::TransactionPoolHandle<Block, ParachainClient<Block, RuntimeApi>>,
 		>,
 		statement_store: Option<Arc<sc_statement_store::Store>>,
+		spawn_handle: Arc<dyn sp_core::traits::SpawnNamed>,
 	) -> sc_service::error::Result<RpcExtension> {
 		let build = || -> Result<RpcExtension, Box<dyn std::error::Error + Send + Sync>> {
 			let mut module = RpcExtension::new(());
@@ -74,7 +76,7 @@ where
 			module.merge(TransactionPayment::new(client.clone()).into_rpc())?;
 			module.merge(StateMigration::new(client.clone(), backend).into_rpc())?;
 			if let Some(statement_store) = statement_store {
-				module.merge(StatementStore::new(statement_store).into_rpc())?;
+				module.merge(StatementStore::new(statement_store, spawn_handle).into_rpc())?;
 			}
 			module.merge(Dev::new(client).into_rpc())?;
 

cumulus/polkadot-omni-node/lib/src/common/spec.rs

@@ -449,18 +449,20 @@ pub(crate) trait NodeSpec: BaseNodeSpec {
 				);
 			}
 
+			let spawn_handle = Arc::new(task_manager.spawn_handle());
+
 			let rpc_builder = {
 				let client = client.clone();
 				let transaction_pool = transaction_pool.clone();
 				let backend_for_rpc = backend.clone();
 				let statement_store = statement_store.clone();
-
 				Box::new(move |_| {
 					Self::BuildRpcExtensions::build_rpc_extensions(
 						client.clone(),
 						backend_for_rpc.clone(),
 						transaction_pool.clone(),
 						statement_store.clone(),
+						spawn_handle.clone(),
 					)
 				})
 			};

cumulus/polkadot-omni-node/lib/src/common/statement_store.rs

@@ -70,7 +70,7 @@ pub(crate) fn build_statement_store<
 		client,
 		local_keystore,
 		parachain_config.prometheus_registry(),
-		&task_manager.spawn_handle(),
+		Box::new(task_manager.spawn_handle()),
 	)
 	.map_err(|e| sc_service::Error::Application(Box::new(e) as Box<_>))?;
 	let statement_protocol_executor = {

cumulus/polkadot-omni-node/lib/src/nodes/aura.rs

@@ -351,7 +351,7 @@ where
 				);
 			},
 		}
-
+		let spawn_handle = Arc::new(task_manager.spawn_handle());
 		let rpc_extensions_builder = {
 			let client = client.clone();
 			let transaction_pool = transaction_pool.clone();
@@ -363,6 +363,7 @@ where
 					backend_for_rpc.clone(),
 					transaction_pool.clone(),
 					None,
+					spawn_handle.clone(),
 				)?;
 				Ok(module)
 			})

cumulus/zombienet/zombienet-sdk/Cargo.toml

@@ -21,7 +21,7 @@ zombienet-orchestrator = { workspace = true }
 zombienet-configuration = { workspace = true }
 cumulus-zombienet-sdk-helpers = { workspace = true }
 cumulus-test-runtime = { workspace = true }
-sp-statement-store = { workspace = true, default-features = true }
+sp-statement-store = { workspace = true, features = ["serde"], default-features = true }
 sc-statement-store = { workspace = true, default-features = true }
 sp-keyring = { workspace = true, default-features = true }
 sp-core = { workspace = true, default-features = true }

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

@@ -4,8 +4,11 @@
 // Test that people-westend enables the statement store in the node and that statements are
 // propagated to peers.
 
+use std::time::Duration;
+
 use anyhow::anyhow;
 use sp_core::{Bytes, Encode};
+use sp_statement_store::{SubmitResult, TopicFilter};
 use zombienet_sdk::{subxt::ext::subxt_rpcs::rpc_params, NetworkConfigBuilder};
 
 #[tokio::test(flavor = "multi_thread")]
@@ -36,7 +39,7 @@ async fn statement_store() -> Result<(), anyhow::Error> {
 				.with_chain("people-westend-local")
 				.with_default_args(vec![
 					"--force-authoring".into(),
-					"-lparachain=debug".into(),
+					"-linfo,statement-gossip=debug,statement-store=debug".into(),
 					"--enable-statement-store".into(),
 				])
 				.with_collator(|n| n.with_name("charlie"))
@@ -64,40 +67,42 @@ async fn statement_store() -> Result<(), anyhow::Error> {
 
 	// Create the statement "1,2,3" signed by dave.
 	let mut statement = sp_statement_store::Statement::new();
+	let topic = [0u8; 32]; // just a dummy topic
 	statement.set_plain_data(vec![1, 2, 3]);
+	statement.set_topic(0, topic);
+	statement.set_expiry_from_parts(u32::MAX, 0);
 	let dave = sp_keyring::Sr25519Keyring::Dave;
 	statement.sign_sr25519_private(&dave.pair());
 	let statement: Bytes = statement.encode().into();
+	// Subscribe to statements with topic "topic" to dave.
+	let stop_after_secs = 20;
+	let mut subscription = dave_rpc
+		.subscribe::<Bytes>(
+			"statement_subscribeStatement",
+			rpc_params![TopicFilter::MatchAll(vec![topic.to_vec().into()])],
+			"statement_unsubscribeStatement",
+		)
+		.await?;
 
 	// Submit the statement to charlie.
-	let _: () = charlie_rpc.request("statement_submit", rpc_params![statement.clone()]).await?;
-
-	// Ensure that charlie stored the statement.
-	let charlie_dump: Vec<Bytes> = charlie_rpc.request("statement_dump", rpc_params![]).await?;
-	if charlie_dump != vec![statement.clone()] {
-		return Err(anyhow!("Charlie did not store the statement"));
-	}
-
-	// Query dave until it receives the statement, stop if 20 seconds passed.
-	let query_start_time = std::time::SystemTime::now();
-	let stop_after_secs = 20;
-	loop {
-		let dave_dump: Vec<Bytes> = dave_rpc.request("statement_dump", rpc_params![]).await?;
-		if !dave_dump.is_empty() {
-			if dave_dump != vec![statement.clone()] {
-				return Err(anyhow!("Dave statement store is not the expected one"));
-			}
-			break;
-		}
+	let _: SubmitResult =
+		charlie_rpc.request("statement_submit", rpc_params![statement.clone()]).await?;
 
-		let elapsed =
-			query_start_time.elapsed().map_err(|_| anyhow!("Failed to get elapsed time"))?;
-		if elapsed.as_secs() > stop_after_secs {
-			return Err(anyhow!("Dave did not receive the statement in time"));
-		}
+	let statement_bytes =
+		tokio::time::timeout(Duration::from_secs(stop_after_secs), subscription.next())
+			.await
+			.expect("Should not timeout")
+			.expect("Should receive")
+			.expect("Should not error");
 
-		tokio::time::sleep(core::time::Duration::from_secs(1)).await;
-	}
+	assert_eq!(statement_bytes, statement);
+	// Now make sure no more statements are received.
+	assert!(tokio::time::timeout(Duration::from_secs(stop_after_secs), subscription.next())
+		.await
+		.is_err());
+	log::info!("Statement store test passed");
+	log::info!("Keeping network alive");
 
+	tokio::time::sleep(Duration::from_hours(24)).await;
 	Ok(())
 }