Pass the offchain storage to the MMR RPC

bin/node/cli/src/service.rs

@@ -281,9 +281,10 @@ pub fn new_partial(
 					finality_provider: finality_proof_provider.clone(),
 				},
 				statement_store: rpc_statement_store.clone(),
+				backend: rpc_backend.clone(),
 			};
 
-			node_rpc::create_full(deps, rpc_backend.clone()).map_err(Into::into)
+			node_rpc::create_full(deps).map_err(Into::into)
 		};
 
 		(rpc_extensions_builder, shared_voter_state2)

bin/node/rpc/src/lib.rs

@@ -90,12 +90,23 @@ pub struct FullDeps<C, P, SC, B> {
 	pub grandpa: GrandpaDeps<B>,
 	/// Shared statement store reference.
 	pub statement_store: Arc<dyn sp_statement_store::StatementStore>,
+	/// The backend used by the node.
+	pub backend: Arc<B>,
 }
 
 /// Instantiate all Full RPC extensions.
 pub fn create_full<C, P, SC, B>(
-	deps: FullDeps<C, P, SC, B>,
-	backend: Arc<B>,
+	FullDeps {
+		client,
+		pool,
+		select_chain,
+		chain_spec,
+		deny_unsafe,
+		babe,
+		grandpa,
+		statement_store,
+		backend,
+	}: FullDeps<C, P, SC, B>,
 ) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
 where
 	C: ProvideRuntimeApi<Block>
@@ -130,16 +141,6 @@ where
 	use substrate_state_trie_migration_rpc::{StateMigration, StateMigrationApiServer};
 
 	let mut io = RpcModule::new(());
-	let FullDeps {
-		client,
-		pool,
-		select_chain,
-		chain_spec,
-		deny_unsafe,
-		babe,
-		grandpa,
-		statement_store,
-	} = deps;
 
 	let BabeDeps { keystore, babe_worker_handle } = babe;
 	let GrandpaDeps {
@@ -159,7 +160,15 @@ where
 	// Making synchronous calls in light client freezes the browser currently,
 	// more context: https://github.com/paritytech/substrate/pull/3480
 	// These RPCs should use an asynchronous caller instead.
-	io.merge(Mmr::new(client.clone()).into_rpc())?;
+	io.merge(
+		Mmr::new(
+			client.clone(),
+			backend
+				.offchain_storage()
+				.ok_or_else(|| "Backend doesn't provide an offchain storage")?,
+		)
+		.into_rpc(),
+	)?;
 	io.merge(TransactionPayment::new(client.clone()).into_rpc())?;
 	io.merge(
 		Babe::new(client.clone(), babe_worker_handle.clone(), keystore, select_chain, deny_unsafe)

client/merkle-mountain-range/rpc/src/lib.rs

@@ -30,9 +30,12 @@ use jsonrpsee::{
 };
 use serde::{Deserialize, Serialize};
 
-use sp_api::{NumberFor, ProvideRuntimeApi};
+use sp_api::{ApiExt, NumberFor, ProvideRuntimeApi};
 use sp_blockchain::HeaderBackend;
-use sp_core::Bytes;
+use sp_core::{
+	offchain::{storage::OffchainDb, OffchainDbExt, OffchainStorage},
+	Bytes,
+};
 use sp_mmr_primitives::{Error as MmrError, Proof};
 use sp_runtime::traits::Block as BlockT;
 
@@ -127,26 +130,28 @@ pub trait MmrApi<BlockHash, BlockNumber, MmrHash> {
 }
 
 /// MMR RPC methods.
-pub struct Mmr<Client, Block> {
+pub struct Mmr<Client, Block, S> {
 	client: Arc<Client>,
+	offchain_db: OffchainDb<S>,
 	_marker: PhantomData<Block>,
 }
 
-impl<C, B> Mmr<C, B> {
+impl<C, B, S> Mmr<C, B, S> {
 	/// Create new `Mmr` with the given reference to the client.
-	pub fn new(client: Arc<C>) -> Self {
-		Self { client, _marker: Default::default() }
+	pub fn new(client: Arc<C>, offchain_storage: S) -> Self {
+		Self { client, _marker: Default::default(), offchain_db: OffchainDb::new(offchain_storage) }
 	}
 }
 
 #[async_trait]
-impl<Client, Block, MmrHash> MmrApiServer<<Block as BlockT>::Hash, NumberFor<Block>, MmrHash>
-	for Mmr<Client, (Block, MmrHash)>
+impl<Client, Block, MmrHash, S> MmrApiServer<<Block as BlockT>::Hash, NumberFor<Block>, MmrHash>
+	for Mmr<Client, (Block, MmrHash), S>
 where
 	Block: BlockT,
 	Client: Send + Sync + 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,
 	Client::Api: MmrRuntimeApi<Block, MmrHash, NumberFor<Block>>,
 	MmrHash: Codec + Send + Sync + 'static,
+	S: OffchainStorage + 'static,
 {
 	fn mmr_root(&self, at: Option<<Block as BlockT>::Hash>) -> RpcResult<MmrHash> {
 		let block_hash = at.unwrap_or_else(||
@@ -166,11 +171,13 @@ where
 		best_known_block_number: Option<NumberFor<Block>>,
 		at: Option<<Block as BlockT>::Hash>,
 	) -> RpcResult<LeavesProof<<Block as BlockT>::Hash>> {
-		let api = self.client.runtime_api();
+		let mut api = self.client.runtime_api();
 		let block_hash = at.unwrap_or_else(||
 			// If the block hash is not supplied assume the best block.
 			self.client.info().best_hash);
 
+		api.register_extension(OffchainDbExt::new(self.offchain_db.clone()));
+
 		let (leaves, proof) = api
 			.generate_proof(block_hash, block_numbers, best_known_block_number)
 			.map_err(runtime_error_into_rpc_error)?
@@ -180,14 +187,16 @@ where
 	}
 
 	fn verify_proof(&self, proof: LeavesProof<<Block as BlockT>::Hash>) -> RpcResult<bool> {
-		let api = self.client.runtime_api();
+		let mut api = self.client.runtime_api();
 
 		let leaves = Decode::decode(&mut &proof.leaves.0[..])
 			.map_err(|e| CallError::InvalidParams(anyhow::Error::new(e)))?;
 
 		let decoded_proof = Decode::decode(&mut &proof.proof.0[..])
 			.map_err(|e| CallError::InvalidParams(anyhow::Error::new(e)))?;
 
+		api.register_extension(OffchainDbExt::new(self.offchain_db.clone()));
+
 		api.verify_proof(proof.block_hash, leaves, decoded_proof)
 			.map_err(runtime_error_into_rpc_error)?
 			.map_err(mmr_error_into_rpc_error)?;

client/offchain/src/api.rs

@@ -25,8 +25,8 @@ pub use http::SharedClient;
 use libp2p::{Multiaddr, PeerId};
 use sp_core::{
 	offchain::{
-		self, HttpError, HttpRequestId, HttpRequestStatus, OffchainStorage, OpaqueMultiaddr,
-		OpaqueNetworkState, StorageKind, Timestamp,
+		self, HttpError, HttpRequestId, HttpRequestStatus, OpaqueMultiaddr, OpaqueNetworkState,
+		Timestamp,
 	},
 	OpaquePeerId,
 };
@@ -36,107 +36,6 @@ mod http;
 
 mod timestamp;
 
-fn unavailable_yet<R: Default>(name: &str) -> R {
-	tracing::error!(
-		target: super::LOG_TARGET,
-		"The {:?} API is not available for offchain workers yet. Follow \
-		https://github.com/paritytech/substrate/issues/1458 for details",
-		name
-	);
-	Default::default()
-}
-
-const LOCAL_DB: &str = "LOCAL (fork-aware) DB";
-
-/// Offchain DB reference.
-#[derive(Debug, Clone)]
-pub struct Db<Storage> {
-	/// Persistent storage database.
-	persistent: Storage,
-}
-
-impl<Storage> Db<Storage> {
-	/// Create new instance of Offchain DB.
-	pub fn new(persistent: Storage) -> Self {
-		Self { persistent }
-	}
-
-	/// Create new instance of Offchain DB, backed by the given backend.
-	pub fn from_backend<Backend, Block>(backend: &Backend) -> Option<Db<Backend::OffchainStorage>>
-	where
-		Backend: sc_client_api::Backend<Block>,
-		Block: sp_runtime::traits::Block,
-	{
-		sc_client_api::Backend::offchain_storage(backend).map(|db| Db::new(db))
-	}
-}
-
-impl<Storage: OffchainStorage> offchain::DbExternalities for Db<Storage> {
-	fn local_storage_set(&mut self, kind: StorageKind, key: &[u8], value: &[u8]) {
-		tracing::debug!(
-			target: "offchain-worker::storage",
-			?kind,
-			key = ?array_bytes::bytes2hex("", key),
-			value = ?array_bytes::bytes2hex("", value),
-			"Write",
-		);
-		match kind {
-			StorageKind::PERSISTENT => self.persistent.set(STORAGE_PREFIX, key, value),
-			StorageKind::LOCAL => unavailable_yet(LOCAL_DB),
-		}
-	}
-
-	fn local_storage_clear(&mut self, kind: StorageKind, key: &[u8]) {
-		tracing::debug!(
-			target: "offchain-worker::storage",
-			?kind,
-			key = ?array_bytes::bytes2hex("", key),
-			"Clear",
-		);
-		match kind {
-			StorageKind::PERSISTENT => self.persistent.remove(STORAGE_PREFIX, key),
-			StorageKind::LOCAL => unavailable_yet(LOCAL_DB),
-		}
-	}
-
-	fn local_storage_compare_and_set(
-		&mut self,
-		kind: StorageKind,
-		key: &[u8],
-		old_value: Option<&[u8]>,
-		new_value: &[u8],
-	) -> bool {
-		tracing::debug!(
-			target: "offchain-worker::storage",
-			?kind,
-			key = ?array_bytes::bytes2hex("", key),
-			new_value = ?array_bytes::bytes2hex("", new_value),
-			old_value = ?old_value.as_ref().map(|s| array_bytes::bytes2hex("", s)),
-			"CAS",
-		);
-		match kind {
-			StorageKind::PERSISTENT =>
-				self.persistent.compare_and_set(STORAGE_PREFIX, key, old_value, new_value),
-			StorageKind::LOCAL => unavailable_yet(LOCAL_DB),
-		}
-	}
-
-	fn local_storage_get(&mut self, kind: StorageKind, key: &[u8]) -> Option<Vec<u8>> {
-		let result = match kind {
-			StorageKind::PERSISTENT => self.persistent.get(STORAGE_PREFIX, key),
-			StorageKind::LOCAL => unavailable_yet(LOCAL_DB),
-		};
-		tracing::debug!(
-			target: "offchain-worker::storage",
-			?kind,
-			key = ?array_bytes::bytes2hex("", key),
-			result = ?result.as_ref().map(|s| array_bytes::bytes2hex("", s)),
-			"Read",
-		);
-		result
-	}
-}
-
 /// Asynchronous offchain API.
 ///
 /// NOTE this is done to prevent recursive calls into the runtime
@@ -326,7 +225,7 @@ mod tests {
 		config::MultiaddrWithPeerId, types::ProtocolName, NetworkPeers, NetworkStateInfo,
 		ReputationChange,
 	};
-	use sp_core::offchain::{DbExternalities, Externalities};
+	use sp_core::offchain::{storage::OffchainDb, DbExternalities, Externalities, StorageKind};
 	use std::time::SystemTime;
 
 	pub(super) struct TestNetwork();
@@ -416,7 +315,7 @@ mod tests {
 	}
 
 	fn offchain_db() -> Db<LocalStorage> {
-		Db::new(LocalStorage::new_test())
+		OffchainDb::new(LocalStorage::new_test())
 	}
 
 	#[test]

client/offchain/src/lib.rs

@@ -54,7 +54,7 @@ use threadpool::ThreadPool;
 
 mod api;
 
-pub use api::Db as OffchainDb;
+pub use sp_core::offchain::storage::OffchainDb;
 pub use sp_offchain::{OffchainWorkerApi, STORAGE_PREFIX};
 
 const LOG_TARGET: &str = "offchain-worker";
@@ -133,7 +133,7 @@ pub struct OffchainWorkers<RA, Block: traits::Block, Storage> {
 	shared_http_client: api::SharedClient,
 	enable_http_requests: bool,
 	keystore: Option<KeystorePtr>,
-	offchain_db: Option<api::Db<Storage>>,
+	offchain_db: Option<OffchainDb<Storage>>,
 	transaction_pool: Option<OffchainTransactionPoolFactory<Block>>,
 	network_provider: Arc<dyn NetworkProvider + Send + Sync>,
 	is_validator: bool,
@@ -163,7 +163,7 @@ impl<RA, Block: traits::Block, Storage> OffchainWorkers<RA, Block, Storage> {
 			shared_http_client: api::SharedClient::new(),
 			enable_http_requests,
 			keystore,
-			offchain_db: offchain_db.map(|d| api::Db::new(d)),
+			offchain_db: offchain_db.map(OffchainDb::new),
 			transaction_pool,
 			is_validator,
 			network_provider,

primitives/core/Cargo.toml

@@ -39,6 +39,7 @@ sp-externalities = { version = "0.19.0", optional = true, path = "../externaliti
 futures = { version = "0.3.21", optional = true }
 dyn-clonable = { version = "0.9.0", optional = true }
 thiserror = { version = "1.0.30", optional = true }
+tracing = { version = "0.1.29", optional = true }
 bitflags = "1.3"
 paste = "1.0.7"
 
@@ -113,6 +114,7 @@ std = [
 	"futures/thread-pool",
 	"libsecp256k1/std",
 	"dyn-clonable",
+	"tracing",
 ]
 
 # Serde support without relying on std features.