OCW Api

bin/node-template/node/src/service.rs

@@ -130,11 +130,11 @@ pub fn new_partial(
 			compatibility_mode: Default::default(),
 		})?;
 
-	let statement_store = Arc::new(sc_statement_store::Store::new(
+	let statement_store = sc_statement_store::Store::new_shared(
 		config.database.path().unwrap(),
 		client.clone(),
 		config.prometheus_registry(),
-	)?);
+	)?;
 
 	Ok(sc_service::PartialComponents {
 		client,

bin/node/cli/src/service.rs

@@ -282,11 +282,11 @@ pub fn new_partial(
 		(rpc_extensions_builder, shared_voter_state2)
 	};
 
-	let statement_store = Arc::new(sc_statement_store::Store::new(
+	let statement_store = sc_statement_store::Store::new_shared(
 		config.database.path().unwrap(),
 		client.clone(),
 		config.prometheus_registry(),
-	)?);
+	)?;
 
 	Ok(sc_service::PartialComponents {
 		client,

client/api/Cargo.toml

@@ -34,6 +34,7 @@ sp-externalities = { version = "0.13.0", path = "../../primitives/externalities"
 sp-keystore = { version = "0.13.0", default-features = false, path = "../../primitives/keystore" }
 sp-runtime = { version = "7.0.0", default-features = false, path = "../../primitives/runtime" }
 sp-state-machine = { version = "0.13.0", path = "../../primitives/state-machine" }
+sp-statement-store = { version = "4.0.0-dev", path = "../../primitives/statement-store" }
 sp-storage = { version = "7.0.0", path = "../../primitives/storage" }
 
 [dev-dependencies]

client/api/src/execution_extensions.rs

@@ -165,14 +165,15 @@ pub struct ExecutionExtensions<Block: BlockT> {
 	strategies: ExecutionStrategies,
 	keystore: Option<KeystorePtr>,
 	offchain_db: Option<Box<dyn DbExternalitiesFactory>>,
-	// FIXME: these two are only RwLock because of https://github.com/paritytech/substrate/issues/4587
+	// FIXME: these three are only RwLock because of https://github.com/paritytech/substrate/issues/4587
 	//        remove when fixed.
 	// To break retain cycle between `Client` and `TransactionPool` we require this
 	// extension to be a `Weak` reference.
 	// That's also the reason why it's being registered lazily instead of
 	// during initialization.
 	transaction_pool: RwLock<Option<Weak<dyn OffchainSubmitTransaction<Block>>>>,
 	extensions_factory: RwLock<Box<dyn ExtensionsFactory<Block>>>,
+	statement_store: RwLock<Option<Weak<dyn sp_statement_store::StatementStore>>>,
 }
 
 impl<Block: BlockT> Default for ExecutionExtensions<Block> {
@@ -183,6 +184,7 @@ impl<Block: BlockT> Default for ExecutionExtensions<Block> {
 			offchain_db: None,
 			transaction_pool: RwLock::new(None),
 			extensions_factory: RwLock::new(Box::new(())),
+			statement_store: RwLock::new(None),
 		}
 	}
 }
@@ -195,13 +197,15 @@ impl<Block: BlockT> ExecutionExtensions<Block> {
 		offchain_db: Option<Box<dyn DbExternalitiesFactory>>,
 	) -> Self {
 		let transaction_pool = RwLock::new(None);
+		let statement_store = RwLock::new(None);
 		let extensions_factory = Box::new(());
 		Self {
 			strategies,
 			keystore,
 			offchain_db,
 			extensions_factory: RwLock::new(extensions_factory),
 			transaction_pool,
+			statement_store,
 		}
 	}
 
@@ -223,6 +227,11 @@ impl<Block: BlockT> ExecutionExtensions<Block> {
 		*self.transaction_pool.write() = Some(Arc::downgrade(pool) as _);
 	}
 
+	/// Register statement store extension.
+	pub fn register_statement_store(&self, store: Arc<dyn sp_statement_store::StatementStore>) {
+		*self.statement_store.write() = Some(Arc::downgrade(&store) as _);
+	}
+
 	/// Based on the execution context and capabilities it produces
 	/// the extensions object to support desired set of APIs.
 	pub fn extensions(
@@ -253,6 +262,11 @@ impl<Block: BlockT> ExecutionExtensions<Block> {
 			}
 		}
 
+		if capabilities.contains(offchain::Capabilities::STATEMENT_STORE) {
+			if let Some(store) = self.statement_store.read().as_ref().and_then(|x| x.upgrade()) {
+				extensions.register(sp_statement_store::runtime_api::StatementStoreExt(store));
+			}
+		}
 		if capabilities.contains(offchain::Capabilities::OFFCHAIN_DB_READ) ||
 			capabilities.contains(offchain::Capabilities::OFFCHAIN_DB_WRITE)
 		{

client/statement-store/Cargo.toml

@@ -27,11 +27,9 @@ sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
 sp-core = { version = "7.0.0", path = "../../primitives/core" }
 sp-runtime = { version = "7.0.0", path = "../../primitives/runtime" }
 sp-tracing = { version = "6.0.0", path = "../../primitives/tracing" }
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
 
 [dev-dependencies]
 tempfile = "3.1.0"
 env_logger = "0.9"
-#substrate-test-runtime = { version = "2.0.0", path = "../../test-utils/runtime" }
-#substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
-#substrate-test-runtime-transaction-pool = { version = "2.0.0", path = "../../test-utils/runtime/transaction-pool" }
 

client/statement-store/src/lib.rs

@@ -351,7 +351,24 @@ impl Index {
 
 impl Store {
 	/// Create a new shared store instance. There should only be one per process.
-	pub fn new<Block, Client>(
+	pub fn new_shared<Block, Client>(
+		path: &std::path::Path,
+		client: Arc<Client>,
+		prometheus: Option<&PrometheusRegistry>,
+	) -> Result<Arc<Store>>
+	where
+		Block: BlockT,
+		Block::Hash: From<BlockHash>,
+		Client: ProvideRuntimeApi<Block> + HeaderBackend<Block> + sc_client_api::ExecutorProvider<Block> + Send + Sync + 'static,
+		Client::Api: ValidateStatement<Block>,
+	{
+		let store = Arc::new(Self::new(path, client.clone(), prometheus)?);
+		client.execution_extensions().register_statement_store(store.clone());
+		Ok(store)
+	}
+
+	/// Create a new instance.
+	fn new<Block, Client>(
 		path: &std::path::Path,
 		client: Arc<Client>,
 		prometheus: Option<&PrometheusRegistry>,

primitives/core/src/offchain/mod.rs

@@ -278,16 +278,8 @@ bitflags::bitflags! {
 		const NODE_AUTHORIZATION = 0b0000_1000_0000;
 		/// Access time related functionality
 		const TIME = 0b0001_0000_0000;
-	}
-}
-
-impl Capabilities {
-	/// Return capabilities for rich offchain calls.
-	///
-	/// Those calls should be allowed to sign and submit transactions
-	/// and access offchain workers database (but read only!).
-	pub fn rich_offchain_call() -> Self {
-		Capabilities::TRANSACTION_POOL | Capabilities::KEYSTORE | Capabilities::OFFCHAIN_DB_READ
+		/// Access the statement store.
+		const STATEMENT_STORE = 0b0010_0000_0000;
 	}
 }
 

primitives/statement-store/Cargo.toml

@@ -19,8 +19,9 @@ sp-core = { version = "7.0.0", default-features = false, path = "../core" }
 sp-runtime = { version = "7.0.0", default-features = false, path = "../runtime" }
 sp-std = { version = "5.0.0", default-features = false, path = "../std" }
 sp-api = { version = "4.0.0-dev", default-features = false, path = "../api" }
-sp-io = { version = "7.0.0", default-features = false, path = "../io" }
 sp-application-crypto = { version = "7.0.0", default-features = false, path = "../application-crypto" }
+sp-runtime-interface = { version = "7.0.0", default-features = false, path = "../runtime-interface" }
+sp-externalities = { version = "0.13.0", default-features = false, path = "../externalities" }
 thiserror = {version = "1.0", optional = true }
 log = { version = "0.4.17", optional = true }
 
@@ -31,9 +32,9 @@ std = [
 	"scale-info/std",
 	"sp-core/std",
 	"sp-runtime/std",
+	"sp-runtime-interface/std",
 	"sp-std/std",
 	"sp-api/std",
-	"sp-io/std",
 	"sp-application-crypto/std",
 	"thiserror",
 	"log",

primitives/statement-store/src/lib.rs

@@ -23,6 +23,7 @@
 use codec::{Decode, Encode};
 use scale_info::TypeInfo;
 use sp_application_crypto::RuntimeAppPublic;
+use sp_runtime_interface::pass_by::PassByCodec;
 #[cfg(feature = "std")]
 use sp_core::Pair;
 use sp_std::vec::Vec;
@@ -76,7 +77,7 @@ pub fn hash_encoded(data: &[u8]) -> [u8; 32] {
 }
 
 /// Statement proof.
-#[derive(Encode, Decode, TypeInfo, sp_runtime::RuntimeDebug, Clone, PartialEq, Eq)]
+#[derive(Encode, Decode, TypeInfo, sp_core::RuntimeDebug, Clone, PartialEq, Eq)]
 pub enum Proof {
 	/// Sr25519 Signature.
 	Sr25519 {
@@ -110,7 +111,7 @@ pub enum Proof {
 	},
 }
 
-#[derive(Encode, Decode, TypeInfo, sp_runtime::RuntimeDebug, Clone, PartialEq, Eq)]
+#[derive(Encode, Decode, TypeInfo, sp_core::RuntimeDebug, Clone, PartialEq, Eq)]
 /// Statement attributes. Each statement is a list of 0 or more fields. Fields may only appear in
 /// the order declared here.
 #[repr(u8)]
@@ -131,7 +132,7 @@ pub enum Field {
 	Data(Vec<u8>) = 6,
 }
 
-#[derive(TypeInfo, sp_runtime::RuntimeDebug, Clone, PartialEq, Eq, Default)]
+#[derive(TypeInfo, sp_core::RuntimeDebug, PassByCodec, Clone, PartialEq, Eq, Default)]
 /// Statement structure.
 pub struct Statement {
 	proof: Option<Proof>,
@@ -296,7 +297,8 @@ impl Statement {
 				let signature = sp_core::ecdsa::Signature(*signature);
 				let public = sp_core::ecdsa::Public(*signer);
 				if signature.verify(to_sign.as_slice(), &public) {
-					SignatureVerificationResult::Valid(sp_io::hashing::blake2_256(signer))
+					let sender_hash = <sp_runtime::traits::BlakeTwo256 as sp_core::Hasher>::hash(signer);
+					SignatureVerificationResult::Valid(sender_hash.into())
 				} else {
 					SignatureVerificationResult::Invalid
 				}

primitives/statement-store/src/runtime_api.rs

@@ -17,10 +17,13 @@
 
 //! Runtime support for the statement store.
 
-use crate::Statement;
+use crate::{Topic, Statement, Hash};
 use codec::{Decode, Encode};
 use scale_info::TypeInfo;
 use sp_runtime::RuntimeDebug;
+use sp_runtime_interface::{runtime_interface, pass_by::PassByEnum};
+use sp_externalities::ExternalitiesExt;
+use sp_std::vec::Vec;
 
 /// Information concerning a valid statement.
 #[derive(Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, TypeInfo)]
@@ -75,3 +78,93 @@ sp_api::decl_runtime_apis! {
 		) -> Result<ValidStatement, InvalidStatement>;
 	}
 }
+
+#[cfg(feature = "std")]
+sp_externalities::decl_extension! {
+	/// The offchain database extension that will be registered at the Substrate externalities.
+	pub struct StatementStoreExt(std::sync::Arc<dyn crate::StatementStore>);
+}
+
+#[cfg(feature = "std")]
+/// Host extensions for the runtime.
+impl StatementStoreExt {
+	/// Create new instance of externalities extensions.
+	pub fn new(store: std::sync::Arc<dyn crate::StatementStore>) -> Self {
+		Self(store)
+	}
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Copy, Encode, Decode, PassByEnum)]
+/// Submission result.
+pub enum SubmitResult {
+	/// Accepted as new.
+	OkNew,
+	/// Known statement
+	OkKnown,
+	/// Statement failed validation.
+	Bad,
+	/// The store is not available.
+	NotAvailable,
+}
+
+/// Host interface
+#[runtime_interface]
+pub trait Io {
+	/// Submit a new new statement. The statement will be broadcast to the network.
+	/// This is meant to be used by the offchain worker.
+	fn submit_statement(&mut self, statement: Statement) -> SubmitResult  {
+		if let Some(StatementStoreExt(store)) = self.extension::<StatementStoreExt>() {
+			match store.submit(statement, StatementSource::Chain) {
+				crate::SubmitResult::New(_) => SubmitResult::OkNew,
+				crate::SubmitResult::Known => SubmitResult::OkKnown,
+				// This should not happen for `StatementSource::Chain`. An existing statement will be
+				// overwritten.
+				crate::SubmitResult::KnownExpired => SubmitResult::Bad,
+				crate::SubmitResult::Bad(_) => SubmitResult::Bad,
+				crate::SubmitResult::InternalError(_) => SubmitResult::Bad,
+			}
+		} else {
+			SubmitResult::NotAvailable
+		}
+	}
+
+	/// Return all statements.
+	fn dump(&mut self) -> Vec<(Hash, Statement)> {
+		if let Some(StatementStoreExt(store)) = self.extension::<StatementStoreExt>() {
+			store.dump().unwrap_or_default()
+		} else {
+			Vec::default()
+		}
+	}
+
+	/// Return the data of all known statements which include all topics and have no `DecryptionKey`
+	/// field.
+	fn broadcasts(&mut self, match_all_topics: &[Topic]) -> Vec<Vec<u8>> {
+		if let Some(StatementStoreExt(store)) = self.extension::<StatementStoreExt>() {
+			store.broadcasts(match_all_topics).unwrap_or_default()
+		} else {
+			Vec::default()
+		}
+	}
+
+	/// Return the data of all known statements whose decryption key is identified as `dest` (this
+	/// will generally be the public key or a hash thereof for symmetric ciphers, or a hash of the
+	/// private key for symmetric ciphers).
+	fn posted(&mut self, match_all_topics: &[Topic], dest: [u8; 32]) -> Vec<Vec<u8>> {
+		if let Some(StatementStoreExt(store)) = self.extension::<StatementStoreExt>() {
+			store.posted(match_all_topics, dest).unwrap_or_default()
+		} else {
+			Vec::default()
+		}
+	}
+
+	/// Return the decrypted data of all known statements whose decryption key is identified as
+	/// `dest`. The key must be available to the client.
+	fn posted_clear(&mut self, match_all_topics: &[Topic], dest: [u8; 32]) -> Vec<Vec<u8>> {
+		if let Some(StatementStoreExt(store)) = self.extension::<StatementStoreExt>() {
+			store.posted_clear(match_all_topics, dest).unwrap_or_default()
+		} else {
+			Vec::default()
+		}
+	}
+}