feat: initialize Kurdistan SDK - independent fork of Polkadot SDK

2025-12-13 15:44:15 +03:00
commit 286de54384
6841 changed files with 1848356 additions and 0 deletions
@@ -0,0 +1,116 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+//! Implementation of the [`DevApiServer`] trait providing debug utilities for Substrate based
+//! blockchains.
+
+#[cfg(test)]
+mod tests;
+
+use jsonrpsee::Extensions;
+use sc_client_api::{BlockBackend, HeaderBackend};
+use sc_rpc_api::{check_if_safe, dev::error::Error};
+use sp_api::{ApiExt, Core, ProvideRuntimeApi};
+use sp_core::Encode;
+use sp_runtime::{
+	generic::DigestItem,
+	traits::{Block as BlockT, Header},
+};
+use std::{
+	marker::{PhantomData, Send, Sync},
+	sync::Arc,
+};
+
+pub use sc_rpc_api::dev::{BlockStats, DevApiServer};
+
+type HasherOf<Block> = <<Block as BlockT>::Header as Header>::Hashing;
+
+/// The Dev API. All methods are unsafe.
+pub struct Dev<Block: BlockT, Client> {
+	client: Arc<Client>,
+	_phantom: PhantomData<Block>,
+}
+
+impl<Block: BlockT, Client> Dev<Block, Client> {
+	/// Create a new Dev API.
+	pub fn new(client: Arc<Client>) -> Self {
+		Self { client, _phantom: PhantomData::default() }
+	}
+}
+
+impl<Block, Client> DevApiServer<Block::Hash> for Dev<Block, Client>
+where
+	Block: BlockT + 'static,
+	Client: BlockBackend<Block>
+		+ HeaderBackend<Block>
+		+ ProvideRuntimeApi<Block>
+		+ Send
+		+ Sync
+		+ 'static,
+	Client::Api: Core<Block>,
+{
+	fn block_stats(
+		&self,
+		ext: &Extensions,
+		hash: Block::Hash,
+	) -> Result<Option<BlockStats>, Error> {
+		check_if_safe(ext)?;
+
+		let block = {
+			let block = self.client.block(hash).map_err(|e| Error::BlockQueryError(Box::new(e)))?;
+			if let Some(block) = block {
+				let (mut header, body) = block.block.deconstruct();
+				// Remove the `Seal` to ensure we have the number of digests as expected by the
+				// runtime.
+				header.digest_mut().logs.retain(|item| !matches!(item, DigestItem::Seal(_, _)));
+				Block::new(header, body)
+			} else {
+				return Ok(None);
+			}
+		};
+		let parent_header = {
+			let parent_hash = *block.header().parent_hash();
+			let parent_header = self
+				.client
+				.header(parent_hash)
+				.map_err(|e| Error::BlockQueryError(Box::new(e)))?;
+			if let Some(header) = parent_header {
+				header
+			} else {
+				return Ok(None);
+			}
+		};
+		let block_len = block.encoded_size() as u64;
+		let num_extrinsics = block.extrinsics().len() as u64;
+		let pre_root = *parent_header.state_root();
+		let mut runtime_api = self.client.runtime_api();
+		runtime_api.record_proof();
+		runtime_api
+			.execute_block(parent_header.hash(), block.into())
+			.map_err(|_| Error::BlockExecutionFailed)?;
+		let witness = runtime_api
+			.extract_proof()
+			.expect("We enabled proof recording. A proof must be available; qed");
+		let witness_len = witness.encoded_size() as u64;
+		let witness_compact_len = witness
+			.into_compact_proof::<HasherOf<Block>>(pre_root)
+			.map_err(|_| Error::WitnessCompactionFailed)?
+			.encoded_size() as u64;
+		Ok(Some(BlockStats { witness_len, witness_compact_len, block_len, num_extrinsics }))
+	}
+}
@@ -0,0 +1,109 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+use super::*;
+use crate::DenyUnsafe;
+use sc_block_builder::BlockBuilderBuilder;
+use sp_blockchain::HeaderBackend;
+use sp_consensus::BlockOrigin;
+use substrate_test_runtime_client::{prelude::*, runtime::Block};
+
+#[tokio::test]
+async fn block_stats_work() {
+	let client = Arc::new(substrate_test_runtime_client::new());
+	let mut api = <Dev<Block, _>>::new(client.clone()).into_rpc();
+	api.extensions_mut().insert(DenyUnsafe::No);
+
+	let block = BlockBuilderBuilder::new(&*client)
+		.on_parent_block(client.chain_info().genesis_hash)
+		.with_parent_block_number(0)
+		.build()
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+
+	let (expected_witness_len, expected_witness_compact_len, expected_block_len) = {
+		let genesis_hash = client.chain_info().genesis_hash;
+		let mut runtime_api = client.runtime_api();
+		runtime_api.record_proof();
+		runtime_api.execute_block(genesis_hash, block.clone().into()).unwrap();
+		let witness = runtime_api.extract_proof().unwrap();
+		let pre_root = *client.header(genesis_hash).unwrap().unwrap().state_root();
+
+		(
+			witness.clone().encoded_size() as u64,
+			witness.into_compact_proof::<HasherOf<Block>>(pre_root).unwrap().encoded_size() as u64,
+			block.encoded_size() as u64,
+		)
+	};
+
+	client.import(BlockOrigin::Own, block).await.unwrap();
+
+	// Can't gather stats for a block without a parent.
+	assert_eq!(
+		api.call::<_, Option<BlockStats>>("dev_getBlockStats", [client.genesis_hash()])
+			.await
+			.unwrap(),
+		None
+	);
+
+	assert_eq!(
+		api.call::<_, Option<BlockStats>>("dev_getBlockStats", [client.info().best_hash])
+			.await
+			.unwrap(),
+		Some(BlockStats {
+			witness_len: expected_witness_len,
+			witness_compact_len: expected_witness_compact_len,
+			block_len: expected_block_len,
+			num_extrinsics: 0,
+		}),
+	);
+}
+
+#[tokio::test]
+async fn deny_unsafe_works() {
+	let client = Arc::new(substrate_test_runtime_client::new());
+	let mut api = <Dev<Block, _>>::new(client.clone()).into_rpc();
+	api.extensions_mut().insert(DenyUnsafe::Yes);
+
+	let block = BlockBuilderBuilder::new(&*client)
+		.on_parent_block(client.chain_info().genesis_hash)
+		.with_parent_block_number(0)
+		.build()
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	client.import(BlockOrigin::Own, block).await.unwrap();
+
+	let best_hash = client.info().best_hash;
+	let best_hash_param =
+		serde_json::to_string(&best_hash).expect("To string must always succeed for block hashes");
+
+	let request = format!(
+		"{{\"jsonrpc\":\"2.0\",\"method\":\"dev_getBlockStats\",\"params\":[{}],\"id\":1}}",
+		best_hash_param
+	);
+	let (resp, _) = api.raw_json_request(&request, 1).await.expect("Raw calls should succeed");
+
+	assert_eq!(
+		resp,
+		r#"{"jsonrpc":"2.0","id":1,"error":{"code":-32601,"message":"RPC call is unsafe to be called externally"}}"#
+	);
+}