A0-1541: Unit tests for pallet snarcos (#722)

Author: pmikolajczyk41

Cargo.lock

@@ -36,6 +36,9 @@ sp-std = { default-features = false, git = "https://github.com/Cardinal-Cryptogr
 
 primitives = { path = "../../primitives", default-features = false }
 
+[dev-dependencies]
+sp-runtime = { default-features = false, git = "https://github.com/Cardinal-Cryptography/substrate.git", branch = "liminal" }
+
 [features]
 default = ["std"]
 std = [
@@ -61,6 +64,7 @@ std = [
     "sp-core/std",
     "sp-io/std",
     "sp-std/std",
+    "sp-runtime/std",
 
     "primitives/std",
 ]

pallets/snarcos/Cargo.toml

@@ -38,7 +38,7 @@ macro_rules! get_artifacts {
 macro_rules! get_artifact {
     ($system:tt, $relation:tt, $artifact:tt $(,)?) => {
         include_bytes!(concat!(
-            "resources/",
+            "../resources/",
             $crate::system!($system),
             "/",
             $crate::relation!($relation),

pallets/snarcos/src/benchmarking/import.rs

@@ -2,9 +2,14 @@
 
 #[cfg(feature = "runtime-benchmarks")]
 mod benchmarking;
+mod systems;
+#[cfg(test)]
+mod tests;
 mod weights;
+
 use frame_support::pallet_prelude::StorageVersion;
 pub use pallet::*;
+pub use systems::ProvingSystem;
 pub use weights::{AlephWeight, WeightInfo};
 
 /// The current storage version.
@@ -13,9 +18,6 @@ const STORAGE_VERSION: StorageVersion = StorageVersion::new(0);
 /// We store verification keys under short identifiers.
 pub type VerificationKeyIdentifier = [u8; 4];
 
-mod systems;
-pub use systems::ProvingSystem;
-
 #[frame_support::pallet]
 pub mod pallet {
     use ark_serialize::CanonicalDeserialize;

pallets/snarcos/src/lib.rs

@@ -0,0 +1,2 @@
+mod setup;
+mod suite;

pallets/snarcos/src/benchmarking/resources/gm17/linear_equation.proof.bytes renamed to pallets/snarcos/src/resources/gm17/linear_equation.proof.bytes

@@ -0,0 +1,67 @@
+use frame_support::{
+    construct_runtime,
+    pallet_prelude::ConstU32,
+    sp_runtime,
+    sp_runtime::{
+        testing::{Header, H256},
+        traits::IdentityLookup,
+    },
+    traits::Everything,
+};
+use frame_system::mocking::{MockBlock, MockUncheckedExtrinsic};
+use sp_io::TestExternalities;
+use sp_runtime::traits::BlakeTwo256;
+
+use crate as pallet_snarcos;
+
+construct_runtime!(
+    pub enum TestRuntime where
+        Block = MockBlock<TestRuntime>,
+        NodeBlock = MockBlock<TestRuntime>,
+        UncheckedExtrinsic = MockUncheckedExtrinsic<TestRuntime>,
+    {
+        System: frame_system::{Pallet, Call, Storage, Config, Event<T>},
+        Snarcos: pallet_snarcos::{Pallet, Call, Storage, Event<T>},
+    }
+);
+
+impl frame_system::Config for TestRuntime {
+    type BaseCallFilter = Everything;
+    type BlockWeights = ();
+    type BlockLength = ();
+    type Origin = Origin;
+    type Call = Call;
+    type Index = u64;
+    type BlockNumber = u64;
+    type Hash = H256;
+    type Hashing = BlakeTwo256;
+    type AccountId = u128;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type Header = Header;
+    type Event = Event;
+    type BlockHashCount = ();
+    type DbWeight = ();
+    type Version = ();
+    type PalletInfo = PalletInfo;
+    type AccountData = ();
+    type OnNewAccount = ();
+    type OnKilledAccount = ();
+    type SystemWeightInfo = ();
+    type SS58Prefix = ();
+    type OnSetCode = ();
+    type MaxConsumers = ConstU32<16>;
+}
+
+impl pallet_snarcos::Config for TestRuntime {
+    type Event = Event;
+    type WeightInfo = ();
+    type MaximumVerificationKeyLength = ConstU32<10_000>;
+}
+
+pub(super) fn new_test_ext() -> TestExternalities {
+    let t = frame_system::GenesisConfig::default()
+        .build_storage::<TestRuntime>()
+        .unwrap();
+
+    TestExternalities::new(t)
+}

pallets/snarcos/src/benchmarking/resources/gm17/linear_equation.public_input.bytes renamed to pallets/snarcos/src/resources/gm17/linear_equation.public_input.bytes

@@ -0,0 +1,156 @@
+use frame_support::{assert_err, assert_ok, sp_runtime, BoundedVec};
+use frame_system::{pallet_prelude::OriginFor, Config};
+use sp_runtime::traits::Get;
+
+use super::setup::*;
+use crate::{Error, ProvingSystem, VerificationKeyIdentifier, VerificationKeys};
+
+type Snarcos = crate::Pallet<TestRuntime>;
+
+const IDENTIFIER: VerificationKeyIdentifier = [0; 4];
+const SYSTEM: ProvingSystem = ProvingSystem::Groth16;
+
+fn vk() -> Vec<u8> {
+    include_bytes!("../resources/groth16/xor.vk.bytes").to_vec()
+}
+
+fn proof() -> Vec<u8> {
+    include_bytes!("../resources/groth16/xor.proof.bytes").to_vec()
+}
+
+fn input() -> Vec<u8> {
+    include_bytes!("../resources/groth16/xor.public_input.bytes").to_vec()
+}
+
+fn caller() -> OriginFor<TestRuntime> {
+    <TestRuntime as Config>::Origin::signed(0)
+}
+
+fn put_key() {
+    VerificationKeys::<TestRuntime>::insert(IDENTIFIER, BoundedVec::try_from(vk()).unwrap());
+}
+
+#[test]
+fn stores_vk_with_fresh_identifier() {
+    new_test_ext().execute_with(|| {
+        assert_ok!(Snarcos::store_key(caller(), IDENTIFIER, vk()));
+
+        let stored_key = VerificationKeys::<TestRuntime>::get(IDENTIFIER);
+        assert!(stored_key.is_some());
+        assert_eq!(stored_key.unwrap().to_vec(), vk());
+    });
+}
+
+#[test]
+fn does_not_overwrite_registered_key() {
+    new_test_ext().execute_with(|| {
+        put_key();
+
+        assert_err!(
+            Snarcos::store_key(caller(), IDENTIFIER, vk()),
+            Error::<TestRuntime>::IdentifierAlreadyInUse
+        );
+    });
+}
+
+#[test]
+fn does_not_store_too_long_key() {
+    new_test_ext().execute_with(|| {
+        let limit: u32 = <TestRuntime as crate::Config>::MaximumVerificationKeyLength::get();
+
+        assert_err!(
+            Snarcos::store_key(caller(), IDENTIFIER, vec![0; (limit + 1) as usize]),
+            Error::<TestRuntime>::VerificationKeyTooLong
+        );
+    });
+}
+
+#[test]
+fn verifies_proof() {
+    new_test_ext().execute_with(|| {
+        put_key();
+
+        assert_ok!(Snarcos::verify(
+            caller(),
+            IDENTIFIER,
+            proof(),
+            input(),
+            SYSTEM
+        ));
+    });
+}
+
+#[test]
+fn verify_shouts_when_no_key_was_registered() {
+    new_test_ext().execute_with(|| {
+        assert_err!(
+            Snarcos::verify(caller(), IDENTIFIER, proof(), input(), SYSTEM),
+            Error::<TestRuntime>::UnknownVerificationKeyIdentifier
+        );
+    });
+}
+
+#[test]
+fn verify_shouts_when_key_is_not_decodable() {
+    new_test_ext().execute_with(|| {
+        VerificationKeys::<TestRuntime>::insert(
+            IDENTIFIER,
+            BoundedVec::try_from(vec![0, 1, 2]).unwrap(),
+        );
+
+        assert_err!(
+            Snarcos::verify(caller(), IDENTIFIER, proof(), input(), SYSTEM),
+            Error::<TestRuntime>::DeserializingVerificationKeyFailed
+        );
+    });
+}
+
+#[test]
+fn verify_shouts_when_proof_is_not_decodable() {
+    new_test_ext().execute_with(|| {
+        put_key();
+
+        assert_err!(
+            Snarcos::verify(caller(), IDENTIFIER, input(), input(), SYSTEM),
+            Error::<TestRuntime>::DeserializingProofFailed
+        );
+    });
+}
+
+#[test]
+fn verify_shouts_when_input_is_not_decodable() {
+    new_test_ext().execute_with(|| {
+        put_key();
+
+        assert_err!(
+            Snarcos::verify(caller(), IDENTIFIER, proof(), proof(), SYSTEM),
+            Error::<TestRuntime>::DeserializingPublicInputFailed
+        );
+    });
+}
+
+#[test]
+fn verify_shouts_when_verification_fails() {
+    new_test_ext().execute_with(|| {
+        put_key();
+        let other_input = include_bytes!("../resources/groth16/linear_equation.public_input.bytes");
+
+        assert_err!(
+            Snarcos::verify(caller(), IDENTIFIER, proof(), other_input.to_vec(), SYSTEM),
+            Error::<TestRuntime>::VerificationFailed
+        );
+    });
+}
+
+#[test]
+fn verify_shouts_when_proof_is_incorrect() {
+    new_test_ext().execute_with(|| {
+        put_key();
+        let other_proof = include_bytes!("../resources/groth16/linear_equation.proof.bytes");
+
+        assert_err!(
+            Snarcos::verify(caller(), IDENTIFIER, other_proof.to_vec(), input(), SYSTEM),
+            Error::<TestRuntime>::IncorrectProof
+        );
+    });
+}