pallet-mmr: RPC API and Runtime API work with block numbers

bin/node/rpc/src/lib.rs

@@ -109,7 +109,11 @@ where
 		+ 'static,
 	C::Api: substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>,
 	C::Api: pallet_contracts_rpc::ContractsRuntimeApi<Block, AccountId, Balance, BlockNumber, Hash>,
-	C::Api: pallet_mmr_rpc::MmrRuntimeApi<Block, <Block as sp_runtime::traits::Block>::Hash>,
+	C::Api: pallet_mmr_rpc::MmrRuntimeApi<
+		Block,
+		<Block as sp_runtime::traits::Block>::Hash,
+		BlockNumber,
+	>,
 	C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>,
 	C::Api: BabeApi<Block>,
 	C::Api: BlockBuilder<Block>,

bin/node/runtime/src/lib.rs

@@ -2013,6 +2013,7 @@ impl_runtime_apis! {
 	impl pallet_mmr::primitives::MmrApi<
 		Block,
 		mmr::Hash,
+		BlockNumber,
 	> for Runtime {
 		fn generate_proof(leaf_index: pallet_mmr::primitives::LeafIndex)
 			-> Result<(mmr::EncodableOpaqueLeaf, mmr::Proof<mmr::Hash>), mmr::Error>
@@ -2073,6 +2074,10 @@ impl_runtime_apis! {
 			let nodes = leaves.into_iter().map(|leaf|mmr::DataOrHash::Data(leaf.into_opaque_leaf())).collect();
 			pallet_mmr::verify_leaves_proof::<mmr::Hashing, _>(root, nodes, proof)
 		}
+
+		fn block_num_to_leaf_index(block_num: &BlockNumber) -> Result<mmr::LeafIndex, mmr::Error> {
+			Ok(Mmr::block_num_to_leaf_index(*block_num))
+		}
 	}
 
 	impl sp_session::SessionKeys<Block> for Runtime {

client/beefy/src/lib.rs

@@ -187,7 +187,7 @@ where
 	BE: Backend<B>,
 	C: Client<B, BE>,
 	R: ProvideRuntimeApi<B>,
-	R::Api: BeefyApi<B> + MmrApi<B, MmrRootHash>,
+	R::Api: BeefyApi<B> + MmrApi<B, MmrRootHash, u64>,
 	N: GossipNetwork<B> + Clone + SyncOracle + Send + Sync + 'static,
 {
 	/// BEEFY client
@@ -219,7 +219,7 @@ where
 	BE: Backend<B>,
 	C: Client<B, BE>,
 	R: ProvideRuntimeApi<B>,
-	R::Api: BeefyApi<B> + MmrApi<B, MmrRootHash>,
+	R::Api: BeefyApi<B> + MmrApi<B, MmrRootHash, u64>,
 	N: GossipNetwork<B> + Clone + SyncOracle + Send + Sync + 'static,
 {
 	let BeefyParams {

client/beefy/src/tests.rs

@@ -250,7 +250,7 @@ macro_rules! create_test_api {
 					}
 				}
 
-				impl MmrApi<Block, MmrRootHash> for RuntimeApi {
+				impl MmrApi<Block, MmrRootHash, u64> for RuntimeApi {
 					fn generate_proof(_leaf_index: LeafIndex)
 						-> Result<(EncodableOpaqueLeaf, Proof<MmrRootHash>), MmrError> {
 						unimplemented!()
@@ -345,7 +345,7 @@ fn initialize_beefy<API>(
 ) -> impl Future<Output = ()>
 where
 	API: ProvideRuntimeApi<Block> + Default + Sync + Send,
-	API::Api: BeefyApi<Block> + MmrApi<Block, MmrRootHash>,
+	API::Api: BeefyApi<Block> + MmrApi<Block, MmrRootHash, u64>,
 {
 	let voters = FuturesUnordered::new();
 

client/beefy/src/worker.rs

@@ -224,7 +224,7 @@ where
 	BE: Backend<B>,
 	C: Client<B, BE>,
 	R: ProvideRuntimeApi<B>,
-	R::Api: BeefyApi<B> + MmrApi<B, MmrRootHash>,
+	R::Api: BeefyApi<B> + MmrApi<B, MmrRootHash, u64>,
 	SO: SyncOracle + Send + Sync + Clone + 'static,
 {
 	/// Return a new BEEFY worker instance.

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

@@ -33,7 +33,7 @@ use serde::{Deserialize, Serialize};
 use sp_api::ProvideRuntimeApi;
 use sp_blockchain::HeaderBackend;
 use sp_core::Bytes;
-use sp_mmr_primitives::{BatchProof, Error as MmrError, LeafIndex, Proof};
+use sp_mmr_primitives::{BatchProof, Error as MmrError, Proof};
 use sp_runtime::{generic::BlockId, traits::Block as BlockT};
 
 pub use sp_mmr_primitives::MmrApi as MmrRuntimeApi;
@@ -96,27 +96,28 @@ impl<BlockHash> LeafBatchProof<BlockHash> {
 
 /// MMR RPC methods.
 #[rpc(client, server)]
-pub trait MmrApi<BlockHash> {
-	/// Generate MMR proof for given leaf index.
+pub trait MmrApi<BlockHash, BlockNumber> {
+	/// Generate MMR proof for given block number.
 	///
 	/// This method calls into a runtime with MMR pallet included and attempts to generate
-	/// MMR proof for leaf at given `leaf_index`.
+	/// MMR proof for leaf at given leaf index that was calculated from the `block_number`.
 	/// Optionally, a block hash at which the runtime should be queried can be specified.
 	///
 	/// Returns the (full) leaf itself and a proof for this leaf (compact encoding, i.e. hash of
 	/// the leaf). Both parameters are SCALE-encoded.
 	#[method(name = "mmr_generateProof")]
 	fn generate_proof(
 		&self,
-		leaf_index: LeafIndex,
+		block_number: BlockNumber,
 		at: Option<BlockHash>,
 	) -> RpcResult<LeafProof<BlockHash>>;
 
-	/// Generate MMR proof for the given leaf indices.
+	/// Generate MMR proof for the given block numbers.
 	///
 	/// This method calls into a runtime with MMR pallet included and attempts to generate
-	/// MMR proof for a set of leaves at the given `leaf_indices`.
-	/// Optionally, a block hash at which the runtime should be queried can be specified.
+	/// MMR proof for a set of leaves at the given leaf indices that are calculated from the
+	/// `block_numbers`. Optionally, a block hash at which the runtime should be queried can be
+	/// specified.
 	///
 	/// Returns the leaves and a proof for these leaves (compact encoding, i.e. hash of
 	/// the leaves). Both parameters are SCALE-encoded.
@@ -125,7 +126,7 @@ pub trait MmrApi<BlockHash> {
 	#[method(name = "mmr_generateBatchProof")]
 	fn generate_batch_proof(
 		&self,
-		leaf_indices: Vec<LeafIndex>,
+		leaf_indices: Vec<BlockNumber>,
 		at: Option<BlockHash>,
 	) -> RpcResult<LeafBatchProof<BlockHash>>;
 }
@@ -144,21 +145,28 @@ impl<C, B> Mmr<C, B> {
 }
 
 #[async_trait]
-impl<Client, Block, MmrHash> MmrApiServer<<Block as BlockT>::Hash> for Mmr<Client, (Block, MmrHash)>
+impl<Client, Block, MmrHash, BlockNumber> MmrApiServer<<Block as BlockT>::Hash, BlockNumber>
+	for Mmr<Client, (Block, MmrHash)>
 where
 	Block: BlockT,
 	Client: Send + Sync + 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,
-	Client::Api: MmrRuntimeApi<Block, MmrHash>,
+	Client::Api: MmrRuntimeApi<Block, MmrHash, BlockNumber>,
 	MmrHash: Codec + Send + Sync + 'static,
+	BlockNumber: Codec,
 {
 	fn generate_proof(
 		&self,
-		leaf_index: LeafIndex,
+		block_number: BlockNumber,
 		at: Option<<Block as BlockT>::Hash>,
 	) -> RpcResult<LeafProof<Block::Hash>> {
 		let api = self.client.runtime_api();
 		let block_hash = at.unwrap_or_else(|| self.client.info().best_hash);
 
+		let leaf_index = api
+			.block_num_to_leaf_index(&BlockId::hash(block_hash), &block_number)
+			.map_err(runtime_error_into_rpc_error)?
+			.map_err(mmr_error_into_rpc_error)?;
+
 		let (leaf, proof) = api
 			.generate_proof_with_context(
 				&BlockId::hash(block_hash),
@@ -173,14 +181,25 @@ where
 
 	fn generate_batch_proof(
 		&self,
-		leaf_indices: Vec<LeafIndex>,
+		block_numbers: Vec<BlockNumber>,
 		at: Option<<Block as BlockT>::Hash>,
 	) -> RpcResult<LeafBatchProof<<Block as BlockT>::Hash>> {
 		let 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);
 
+		let leaf_indices = block_numbers
+			.iter()
+			.map(|n| -> Result<u64, CallError> {
+				let leaf_index = api
+					.block_num_to_leaf_index(&BlockId::hash(block_hash), &n)
+					.map_err(runtime_error_into_rpc_error)?
+					.map_err(mmr_error_into_rpc_error)?;
+				Ok(leaf_index)
+			})
+			.collect::<Result<Vec<u64>, _>>()?;
+
 		let (leaves, proof) = api
 			.generate_batch_proof_with_context(
 				&BlockId::hash(block_hash),

frame/merkle-mountain-range/src/lib.rs

@@ -365,4 +365,20 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			Err(primitives::Error::Verify.log_debug("The proof is incorrect."))
 		}
 	}
+
+	/// Convert `block_num` into a leaf index.
+	pub fn block_num_to_leaf_index(block_num: <T as frame_system::Config>::BlockNumber) -> LeafIndex
+	where
+		T: frame_system::Config,
+		T: pallet::Config,
+	{
+		// leaf_indx = block_num - (current_block_num - leaves_count) - 1;
+		let leaves_count = Pallet::<T>::mmr_leaves();
+		let current_block_num = <frame_system::Pallet<T>>::block_number();
+		let diff = current_block_num.saturating_sub((leaves_count as u32).into());
+
+		// TODO: Somehow convert BlockNumber into LeafIndex.
+		block_num.saturating_sub(diff).saturating_sub(1u32.into());
+		0
+	}
 }

primitives/merkle-mountain-range/src/lib.rs

@@ -431,7 +431,7 @@ impl Error {
 
 sp_api::decl_runtime_apis! {
 	/// API to interact with MMR pallet.
-	pub trait MmrApi<Hash: codec::Codec> {
+	pub trait MmrApi<Hash: codec::Codec, BlockNumber: codec::Codec> {
 		/// Generate MMR proof for a leaf under given index.
 		fn generate_proof(leaf_index: LeafIndex) -> Result<(EncodableOpaqueLeaf, Proof<Hash>), Error>;
 
@@ -474,6 +474,9 @@ sp_api::decl_runtime_apis! {
 		/// same position in both the `leaves` vector and the `leaf_indices` vector contained in the [BatchProof]
 		fn verify_batch_proof_stateless(root: Hash, leaves: Vec<EncodableOpaqueLeaf>, proof: BatchProof<Hash>)
 			-> Result<(), Error>;
+
+		/// Converts `block_num` into a leaf index.
+		fn block_num_to_leaf_index(block_num: &BlockNumber) -> Result<LeafIndex, Error>;
 	}
 }