feat: initialize Kurdistan SDK - independent fork of Polkadot SDK

substrate/primitives/application-crypto/test/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "sp-application-crypto-test"
+version = "2.0.0"
+authors.workspace = true
+edition.workspace = true
+description = "Integration tests for application-crypto"
+license = "Apache-2.0"
+publish = false
+homepage.workspace = true
+repository.workspace = true
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+sp-api = { workspace = true, default-features = true }
+sp-application-crypto = { workspace = true, default-features = true }
+sp-core = { workspace = true }
+sp-keystore = { workspace = true }
+sp-tracing = { workspace = true, default-features = true }
+substrate-test-runtime-client = { workspace = true }
+
+[features]
+bls-experimental = ["substrate-test-runtime-client/bls-experimental"]
+runtime-benchmarks = [
+	"sp-api/runtime-benchmarks",
+	"substrate-test-runtime-client/runtime-benchmarks",
+]

substrate/primitives/application-crypto/test/src/bls381.rs

@@ -0,0 +1,69 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Integration tests for bls12-381
+
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_application_crypto::{bls381::AppPair, RuntimePublic};
+use sp_core::{
+	bls381::Pair as Bls381Pair,
+	crypto::ByteArray,
+	proof_of_possession::{ProofOfPossessionGenerator, ProofOfPossessionVerifier},
+	testing::BLS381,
+	Pair,
+};
+use sp_keystore::{testing::MemoryKeystore, Keystore, KeystoreExt};
+use std::sync::Arc;
+use substrate_test_runtime_client::{
+	runtime::{TestAPI, TEST_OWNER},
+	DefaultTestClientBuilderExt, TestClientBuilder, TestClientBuilderExt,
+};
+
+#[test]
+fn bls381_works_in_runtime() {
+	sp_tracing::try_init_simple();
+	let keystore = Arc::new(MemoryKeystore::new());
+	let test_client = TestClientBuilder::new().build();
+
+	let mut runtime_api = test_client.runtime_api();
+	runtime_api.register_extension(KeystoreExt::new(keystore.clone()));
+
+	let (proof_of_possession, public) = runtime_api
+		.test_bls381_crypto(test_client.chain_info().genesis_hash)
+		.expect("Tests `bls381` crypto.");
+
+	let supported_keys = keystore.keys(BLS381).unwrap();
+	assert!(supported_keys.contains(&public.to_raw_vec()));
+
+	assert!(AppPair::verify_proof_of_possession(
+		TEST_OWNER,
+		&proof_of_possession.into(),
+		&public.into()
+	));
+}
+
+#[test]
+fn bls381_client_proof_of_possession_verified_by_runtime_public() {
+	let (mut test_pair, _) = Bls381Pair::generate();
+
+	let client_generated_proof_of_possession = test_pair.generate_proof_of_possession(TEST_OWNER);
+	assert!(RuntimePublic::verify_proof_of_possession(
+		&test_pair.public(),
+		TEST_OWNER,
+		&client_generated_proof_of_possession
+	));
+}

substrate/primitives/application-crypto/test/src/ecdsa.rs

@@ -0,0 +1,67 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Integration tests for ecdsa
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_application_crypto::{ecdsa::AppPair, RuntimePublic};
+use sp_core::{
+	crypto::{ByteArray, Pair},
+	ecdsa::Pair as ECDSAPair,
+	proof_of_possession::{ProofOfPossessionGenerator, ProofOfPossessionVerifier},
+	testing::ECDSA,
+};
+use sp_keystore::{testing::MemoryKeystore, Keystore, KeystoreExt};
+use std::sync::Arc;
+use substrate_test_runtime_client::{
+	runtime::{TestAPI, TEST_OWNER},
+	DefaultTestClientBuilderExt, TestClientBuilder, TestClientBuilderExt,
+};
+
+#[test]
+fn ecdsa_works_in_runtime() {
+	sp_tracing::try_init_simple();
+	let keystore = Arc::new(MemoryKeystore::new());
+	let test_client = TestClientBuilder::new().build();
+
+	let mut runtime_api = test_client.runtime_api();
+	runtime_api.register_extension(KeystoreExt::new(keystore.clone()));
+
+	let (signature, public, proof_of_possession) = runtime_api
+		.test_ecdsa_crypto(test_client.chain_info().genesis_hash)
+		.expect("Tests `ecdsa` crypto.");
+
+	let supported_keys = keystore.keys(ECDSA).unwrap();
+	assert!(supported_keys.contains(&public.to_raw_vec()));
+	assert!(AppPair::verify(&signature, "ecdsa", &public));
+	assert!(AppPair::verify_proof_of_possession(
+		TEST_OWNER,
+		&proof_of_possession.into(),
+		&public.into()
+	));
+}
+
+#[test]
+fn ecdsa_client_generated_proof_of_possession_verified_by_runtime_public() {
+	let (mut test_pair, _) = ECDSAPair::generate();
+
+	let client_generated_proof_of_possession = test_pair.generate_proof_of_possession(TEST_OWNER);
+	assert!(RuntimePublic::verify_proof_of_possession(
+		&test_pair.public(),
+		TEST_OWNER,
+		&client_generated_proof_of_possession
+	));
+}

substrate/primitives/application-crypto/test/src/ecdsa_bls381.rs

@@ -0,0 +1,70 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Integration tests for ecdsa-bls12-381
+
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_application_crypto::{ecdsa_bls381::AppPair, RuntimePublic};
+use sp_core::{
+	crypto::ByteArray,
+	ecdsa_bls381::Pair as EcdsaBls381Pair,
+	proof_of_possession::{ProofOfPossessionGenerator, ProofOfPossessionVerifier},
+	testing::ECDSA_BLS381,
+	Pair,
+};
+use sp_keystore::{testing::MemoryKeystore, Keystore, KeystoreExt};
+use std::sync::Arc;
+use substrate_test_runtime_client::{
+	runtime::{TestAPI, TEST_OWNER},
+	DefaultTestClientBuilderExt, TestClientBuilder, TestClientBuilderExt,
+};
+
+#[test]
+fn ecdsa_bls381_works_in_runtime() {
+	sp_tracing::try_init_simple();
+	let keystore = Arc::new(MemoryKeystore::new());
+	let test_client = TestClientBuilder::new().build();
+
+	let mut runtime_api = test_client.runtime_api();
+	runtime_api.register_extension(KeystoreExt::new(keystore.clone()));
+
+	let (proof_of_possession, public) = runtime_api
+		.test_ecdsa_bls381_crypto(test_client.chain_info().genesis_hash)
+		.expect("Tests `ecdsa_bls381` crypto.");
+
+	let supported_keys = keystore.keys(ECDSA_BLS381).unwrap();
+	assert!(supported_keys.contains(&public.to_raw_vec()));
+	assert!(supported_keys.len() == 3);
+
+	assert!(AppPair::verify_proof_of_possession(
+		TEST_OWNER,
+		&proof_of_possession.into(),
+		&public.into()
+	));
+}
+
+#[test]
+fn ecdsa_bls381_client_proof_of_possession_verified_by_runtime_public() {
+	let (mut test_pair, _) = EcdsaBls381Pair::generate();
+
+	let client_generated_proof_of_possession = test_pair.generate_proof_of_possession(TEST_OWNER);
+	assert!(RuntimePublic::verify_proof_of_possession(
+		&test_pair.public(),
+		TEST_OWNER,
+		&client_generated_proof_of_possession
+	));
+}

substrate/primitives/application-crypto/test/src/ed25519.rs

@@ -0,0 +1,68 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Integration tests for ed25519
+
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_application_crypto::{ed25519::AppPair, RuntimePublic};
+use sp_core::{
+	crypto::{ByteArray, Pair},
+	ed25519::Pair as Ed25519Pair,
+	proof_of_possession::{ProofOfPossessionGenerator, ProofOfPossessionVerifier},
+	testing::ED25519,
+};
+use sp_keystore::{testing::MemoryKeystore, Keystore, KeystoreExt};
+use std::sync::Arc;
+use substrate_test_runtime_client::{
+	runtime::{TestAPI, TEST_OWNER},
+	DefaultTestClientBuilderExt, TestClientBuilder, TestClientBuilderExt,
+};
+
+#[test]
+fn ed25519_works_in_runtime() {
+	sp_tracing::try_init_simple();
+	let keystore = Arc::new(MemoryKeystore::new());
+	let test_client = TestClientBuilder::new().build();
+
+	let mut runtime_api = test_client.runtime_api();
+	runtime_api.register_extension(KeystoreExt::new(keystore.clone()));
+
+	let (signature, public, proof_of_possession) = runtime_api
+		.test_ed25519_crypto(test_client.chain_info().genesis_hash)
+		.expect("Tests `ed25519` crypto.");
+
+	let supported_keys = keystore.keys(ED25519).unwrap();
+	assert!(supported_keys.contains(&public.to_raw_vec()));
+	assert!(AppPair::verify(&signature, "ed25519", &public));
+	assert!(AppPair::verify_proof_of_possession(
+		TEST_OWNER,
+		&proof_of_possession.into(),
+		&public.into()
+	));
+}
+
+#[test]
+fn ed25519_client_proof_of_possession_verified_by_runtime_public() {
+	let (mut test_pair, _) = Ed25519Pair::generate();
+
+	let client_generated_proof_of_possession = test_pair.generate_proof_of_possession(TEST_OWNER);
+	assert!(RuntimePublic::verify_proof_of_possession(
+		&test_pair.public(),
+		TEST_OWNER,
+		&client_generated_proof_of_possession
+	));
+}

substrate/primitives/application-crypto/test/src/lib.rs

@@ -0,0 +1,30 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Integration tests for application crypto
+
+#[cfg(all(test, feature = "bls-experimental"))]
+mod bls381;
+#[cfg(test)]
+mod ecdsa;
+#[cfg(test)]
+mod ed25519;
+#[cfg(test)]
+mod sr25519;
+
+#[cfg(all(test, feature = "bls-experimental"))]
+mod ecdsa_bls381;

substrate/primitives/application-crypto/test/src/sr25519.rs

@@ -0,0 +1,68 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Integration tests for sr25519
+
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_application_crypto::{sr25519::AppPair, RuntimePublic};
+use sp_core::{
+	crypto::{ByteArray, Pair},
+	proof_of_possession::{ProofOfPossessionGenerator, ProofOfPossessionVerifier},
+	sr25519::Pair as Sr25519Pair,
+	testing::SR25519,
+};
+use sp_keystore::{testing::MemoryKeystore, Keystore, KeystoreExt};
+use std::sync::Arc;
+use substrate_test_runtime_client::{
+	runtime::{TestAPI, TEST_OWNER},
+	DefaultTestClientBuilderExt, TestClientBuilder, TestClientBuilderExt,
+};
+
+#[test]
+fn sr25519_works_in_runtime() {
+	sp_tracing::try_init_simple();
+	let keystore = Arc::new(MemoryKeystore::new());
+	let test_client = TestClientBuilder::new().build();
+
+	let mut runtime_api = test_client.runtime_api();
+	runtime_api.register_extension(KeystoreExt::new(keystore.clone()));
+
+	let (signature, public, proof_of_possession) = runtime_api
+		.test_sr25519_crypto(test_client.chain_info().genesis_hash)
+		.expect("Tests `sr25519` crypto.");
+
+	let supported_keys = keystore.keys(SR25519).unwrap();
+	assert!(supported_keys.contains(&public.to_raw_vec()));
+	assert!(AppPair::verify(&signature, "sr25519", &public));
+	assert!(AppPair::verify_proof_of_possession(
+		TEST_OWNER,
+		&proof_of_possession.into(),
+		&public.into()
+	));
+}
+
+#[test]
+fn sr25519_client_proof_of_possession_verified_by_runtime_public() {
+	let (mut test_pair, _) = Sr25519Pair::generate();
+
+	let client_generated_proof_of_possession = test_pair.generate_proof_of_possession(TEST_OWNER);
+	assert!(RuntimePublic::verify_proof_of_possession(
+		&test_pair.public(),
+		TEST_OWNER,
+		&client_generated_proof_of_possession
+	));
+}