arkworks integration (#13031)

* fix

* fix

* fix

* fix

* fix

* fix

* fix

* fix

* fix

* fix

* fix

* fix

* fix

* fix

* fix compression

* fix compression

* fix compression

* fix compression

* fix compression

* fix std leak

* fix std leak

* fix std leak

* merge master

* merge master

* cargo update

* cargo update

* cargo update

* cargo update

* cargo update

* use serialize_result

* cargo update

* cargo update

* cargo update

* cargo update

* reduce boilerplate code

* remove host function muls

* reduce boilerplate code

* remove patches

* uuse correct ark-substrate branch

* reduce boilerplate code

* cleanup

* cleanup

* proper error handling

* derive serialize for error

* proper error handling

* proper error handling

* proper error handling

* derive Debug for PairingError

* sp-arkworks path

* cargo update

* adopt tests to error handling

* fix tests

* cargo update

* remove results

* deserialize as G2Affine

* cargo update

* add codex index to PairingError

* replace Vec<Vec<u8>>

* replace Vec<Vec<u8>>

* use into_iter for chunks

* use chunks for scalars

* fix ersialized_size

* use into

* collect as vec

* collect as vec

* no collect Vec

* use into_iter

* import AffineRepr

* fix typo

* cargo update

* new serialization

* fix typo

* unwrap results

* unwrap results

* use correct deserialization

* fix bugs, cleanup

* correct len

* vec without capacity

* Revert "vec without capacity"

This reverts commit 2b1cd004f9f3f7cb1b0513c794f9ea781bb75ef1.

* Revert "correct len"

This reverts commit b85de8606364260c310f3c306b0a920e184e7e53.

* Revert "fix bugs, cleanup"

This reverts commit eef4c77ac99c0ed2e4b4857702e6ab5f1d2ce36c.

* Revert "use correct deserialization"

This reverts commit 9eacba93150bd41614e198cc6f2838d57d14f8db.

* Revert "unwrap results"

This reverts commit b0df1e1bdbd2518baa23040e0c6663ca69d2ba25.

* Revert "unwrap results"

This reverts commit de3cfbd04964dd66faeae5616b5763b1d30520e2.

* Revert "fix typo"

This reverts commit c12045d78f2468800be30ee1b31b12768aa7a786.

* Revert "new serialization"

This reverts commit e56a088be7612e4511382817afaf61f65b0c3aca.

* Revert "cargo update"

This reverts commit 15898da94677a5f19290a7f15fb15cb4cbd8f431.

* Revert "fix typo"

This reverts commit c89e96331f1d07e3b9b6a00ea9c89896553d67c6.

* Revert "import AffineRepr"

This reverts commit 5a103ac1b3506736181ddda040d896930bd8f83a.

* Revert "use into_iter"

This reverts commit 2e31d912bd4103529b40b250410f9f5b1a980ce4.

* Revert "no collect Vec"

This reverts commit db18dcac34fc3c3ddc20c3b42331f8d5fa7014b5.

* Revert "collect as vec"

This reverts commit dd3f809e965cec361a0feaab9abfae7115756e2c.

* Revert "collect as vec"

This reverts commit 9167d5984d8ecc3903d24f96d8c9fcac45c87bf7.

* Revert "use into"

This reverts commit 344cfffbd38fde130225df35f36259872754bd3a.

* Revert "fix ersialized_size"

This reverts commit c6a760986551cbbcaa3748564dd5e3c7630209c6.

* Revert "use chunks for scalars"

This reverts commit 67987ae0bbba7e3963ccba0dd9f1fbaa4c922d4f.

* Revert "use into_iter for chunks"

This reverts commit 1ddd6b89c2f8fb4e6dd26768be0edaca2d1be3f9.

* Revert "replace Vec<Vec<u8>>"

This reverts commit 4d3b13c02a9db0ea6bd130bda38c851f2371ec6e.

* cargo update

* cargo update

* Revert "replace Vec<Vec<u8>>"

This reverts commit 4389714068d939abc97288c5b06ee23d399a19ad.

* cargo update

* add error

* add error

* add error

* fix typo

* fix imports

* import coded

* import codec

* import PairingError

* fix patches

* sp-arkworks

* sp-arkworks

* use random values for multiplications

* cargo update

* fix imports

* fix imports

* add host functions

* re-add mul impls

* cargo update

* cargo update

* cargo update

* cargo update

* cargo update

* cargo update

* cargo update

* PairingError -> ()

* remove PairingError

* cargo update

* cargo update

* cargo update

* reduce boilerplate code

* cargo update

* update comments

* cargo update

* optimize code quality

* use ark_scale (#13954)

* use ark_scale

* fix tests

* fix tests

* cleanup & comments

* use correct PR branch

* hazmat

* ed curves, use ArkScaleProjective

* Achimcc/arkworks integration remove affine hostcalls (#13971)

* remove affine host-calls

* remove affine host-call impls, also in tests

* cargo update

* ark-substrate: use main branch

* cargo update

* Achimcc/arkworks integration bandersnatch (#13977)

* use bandersnatch

* bandersnatch

* add abndersnatch sw msm

* use correct PR branch

* cargo update

* cargo update

* fix tests

* cleanup

* cleanup

* fix tests

* refactor tests

* cargo update

* cargo update

* cargo update

* refactor tests

* cleanup & update tests

* upgrade arkworks/algebra

* cargo update

* adopt tests

* versioning ark-substrate

* cargo update

* remove patched deps

* bump ark-scale

* use crates-io deps

* fix doc comments

* Cargo.toml, linebreaks at end

* reorgainze tests

* sp-arkworks -> sp-crypto-ec-utils

* move host functions to crypto-ec-utils

* fmt

* remove sp-ec-crypto-utils from io

* remove unwrap from te msm

* remove elliptic_curves references in test

* elliptic_curves references in test

* update doc comments

* remove warn missing docs

* fmt

* cargo update

* update doc comments

* cargo update

* cargo update, bump arkworks, codec versions

* bump runtime version in sp-crypto-ec-utils

* remove feature flag ec-utils-experimental

* crypto-ec-utils -> crypto/ec-utils

* tests/ -> test-data/

* update doc comments for signatures

* update comments

* update doc comments for signatures

* fix doc comments

* fix doc comments

* fix doc comments

* fix doc comments

* fix doc comments

* cleanup

* fix doc comments

* cargo update

* fix doc comments

* cargo update

substrate/Cargo.toml

@@ -199,6 +199,7 @@ members = [
 	"primitives/core",
 	"primitives/core/hashing",
 	"primitives/core/hashing/proc-macro",
+	"primitives/crypto/ec-utils",
 	"primitives/database",
 	"primitives/debug-derive",
 	"primitives/externalities",

substrate/primitives/crypto/ec-utils/Cargo.toml

+[package]
+name = "sp-crypto-ec-utils"
+version = "0.4.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+ark-serialize = { version = "0.4.2", default-features = false }
+ark-ff = { version = "0.4.2", default-features = false }
+ark-ec = { version = "0.4.2", default-features = false }
+ark-std = { version = "0.4.0", default-features = false }
+ark-bls12-377 = { version = "0.4.0", features = ["curve"], default-features = false }
+ark-bls12-381 = { version = "0.4.0", features = ["curve"], default-features = false }
+ark-bw6-761 = { version = "0.4.0", default-features = false }
+ark-ed-on-bls12-381-bandersnatch = { version = "0.4.0", default-features = false }
+ark-ed-on-bls12-377 = { version = "0.4.0", default-features = false }
+sp-std = { version = "8.0.0", path = "../../std", default-features = false }
+codec = { package = "parity-scale-codec", version = "3.5.0", default-features = false }
+ark-scale = { version = "0.0.3", features = ["hazmat"], default-features = false }
+sp-runtime-interface = { version = "17.0.0", default-features = false, path = "../../runtime-interface" }
+
+[dev-dependencies]
+sp-io = { path = "../../io", default-features = false }
+ark-algebra-test-templates = { version = "0.4.2", default-features = false }
+sp-ark-models = { version = "0.4.0-beta", default-features = false }
+sp-ark-bls12-377 = { version = "0.4.0-beta", default-features = false }
+sp-ark-bls12-381 = { version = "0.4.0-beta", default-features = false }
+sp-ark-bw6-761 = { version = "0.4.0-beta", default-features = false }
+sp-ark-ed-on-bls12-377 = { version = "0.4.0-beta", default-features = false }
+sp-ark-ed-on-bls12-381-bandersnatch = { version = "0.4.0-beta", default-features = false }
+
+[features]
+default = [ "std" ]
+std = [
+	"ark-serialize/std",
+	"ark-ff/std",
+	"ark-ec/std",
+	"ark-std/std",
+	"ark-bls12-377/std",
+	"ark-bls12-381/std",
+	"ark-bw6-761/std",
+	"ark-ed-on-bls12-381-bandersnatch/std",
+	"ark-ed-on-bls12-377/std",
+	"sp-std/std",
+	"codec/std",
+	"ark-scale/std",
+	"sp-runtime-interface/std",
+	"sp-io/std",
+	"ark-algebra-test-templates/std",
+	"sp-ark-bls12-377/std",
+	"sp-ark-bls12-381/std",
+    "sp-ark-bw6-761/std",
+    "sp-ark-ed-on-bls12-377/std",
+    "sp-ark-ed-on-bls12-381-bandersnatch/std",
+]

substrate/primitives/crypto/ec-utils/src/bls12_377.rs

+// This file is part of Substrate.
+
+// Copyright (C) 2017-2022 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.
+
+//! Support functions for bls12_377 to improve the performance of
+//! multi_miller_loop, final_exponentiation, msm's and projective
+//! multiplications by host function calls
+
+use crate::utils::{
+	final_exponentiation_generic, msm_sw_generic, mul_projective_generic, multi_miller_loop_generic,
+};
+use ark_bls12_377::{g1, g2, Bls12_377};
+use sp_std::vec::Vec;
+
+/// Compute a multi miller loop through arkworks
+pub fn multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+	multi_miller_loop_generic::<Bls12_377>(a, b)
+}
+
+/// Compute a final exponentiation through arkworks
+pub fn final_exponentiation(target: Vec<u8>) -> Result<Vec<u8>, ()> {
+	final_exponentiation_generic::<Bls12_377>(target)
+}
+
+/// Compute a multi scalar multiplication for short_weierstrass through
+/// arkworks on G1.
+pub fn msm_g1(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_sw_generic::<g1::Config>(bases, scalars)
+}
+
+/// Compute a multi scalar multiplication for short_weierstrass through
+/// arkworks on G2.
+pub fn msm_g2(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_sw_generic::<g2::Config>(bases, scalars)
+}
+
+/// Compute a projective scalar multiplication for short_weierstrass
+/// through arkworks on G1.
+pub fn mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_generic::<g1::Config>(base, scalar)
+}
+
+/// Compute a projective scalar multiplication for short_weierstrass
+/// through arkworks on G2.
+pub fn mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_generic::<g2::Config>(base, scalar)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use ark_algebra_test_templates::*;
+	use sp_ark_bls12_377::{
+		Bls12_377 as Bls12_377Host, G1Projective as G1ProjectiveHost,
+		G2Projective as G2ProjectiveHost, HostFunctions,
+	};
+
+	#[derive(PartialEq, Eq)]
+	struct Host;
+
+	impl HostFunctions for Host {
+		fn bls12_377_multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_377_multi_miller_loop(a, b)
+		}
+		fn bls12_377_final_exponentiation(f12: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_377_final_exponentiation(f12)
+		}
+		fn bls12_377_msm_g1(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_377_msm_g1(bases, bigints)
+		}
+		fn bls12_377_msm_g2(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_377_msm_g2(bases, bigints)
+		}
+		fn bls12_377_mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_377_mul_projective_g1(base, scalar)
+		}
+		fn bls12_377_mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_377_mul_projective_g2(base, scalar)
+		}
+	}
+
+	type Bls12_377 = Bls12_377Host<Host>;
+	type G1Projective = G1ProjectiveHost<Host>;
+	type G2Projective = G2ProjectiveHost<Host>;
+
+	test_group!(g1; G1Projective; sw);
+	test_group!(g2; G2Projective; sw);
+	test_group!(pairing_output; ark_ec::pairing::PairingOutput<Bls12_377>; msm);
+	test_pairing!(pairing; super::Bls12_377);
+}

substrate/primitives/crypto/ec-utils/src/bls12_381.rs

+// This file is part of Substrate.
+
+// Copyright (C) 2017-2022 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.
+
+//! Support functions for bls12_381 to improve the performance of
+//! multi_miller_loop, final_exponentiation, msm's and projective
+//! multiplications by host function calls
+
+use crate::utils::{
+	final_exponentiation_generic, msm_sw_generic, mul_projective_generic, multi_miller_loop_generic,
+};
+use ark_bls12_381::{g1, g2, Bls12_381};
+use sp_std::vec::Vec;
+
+/// Compute a multi miller loop through arkworks
+pub fn multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+	multi_miller_loop_generic::<Bls12_381>(a, b)
+}
+
+/// Compute a final exponentiation through arkworks
+pub fn final_exponentiation(target: Vec<u8>) -> Result<Vec<u8>, ()> {
+	final_exponentiation_generic::<Bls12_381>(target)
+}
+
+/// Compute a multi scalar multiplication for short_weierstrass through
+/// arkworks on G1.
+pub fn msm_g1(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_sw_generic::<g1::Config>(bases, scalars)
+}
+
+/// Compute a multi scalar multiplication for short_weierstrass through
+/// arkworks on G2.
+pub fn msm_g2(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_sw_generic::<g2::Config>(bases, scalars)
+}
+
+/// Compute a projective scalar multiplication for short_weierstrass
+/// through arkworks on G1.
+pub fn mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_generic::<g1::Config>(base, scalar)
+}
+
+/// Compute a projective scalar multiplication for short_weierstrass
+/// through arkworks on G2.
+pub fn mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_generic::<g2::Config>(base, scalar)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use ark_algebra_test_templates::*;
+	use ark_ec::{AffineRepr, CurveGroup, Group};
+	use ark_ff::{fields::Field, One, Zero};
+	use ark_serialize::{CanonicalDeserialize, CanonicalSerialize, Compress, Validate};
+	use ark_std::{rand::Rng, test_rng, vec, UniformRand};
+	use sp_ark_bls12_381::{
+		fq::Fq, fq2::Fq2, fr::Fr, Bls12_381 as Bls12_381Host, G1Affine as G1AffineHost,
+		G1Projective as G1ProjectiveHost, G2Affine as G2AffineHost,
+		G2Projective as G2ProjectiveHost, HostFunctions,
+	};
+	use sp_ark_models::pairing::PairingOutput;
+
+	#[derive(PartialEq, Eq)]
+	struct Host;
+
+	impl HostFunctions for Host {
+		fn bls12_381_multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_381_multi_miller_loop(a, b)
+		}
+		fn bls12_381_final_exponentiation(f12: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_381_final_exponentiation(f12)
+		}
+		fn bls12_381_msm_g1(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_381_msm_g1(bases, bigints)
+		}
+		fn bls12_381_msm_g2(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_381_msm_g2(bases, bigints)
+		}
+		fn bls12_381_mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_381_mul_projective_g1(base, scalar)
+		}
+		fn bls12_381_mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_381_mul_projective_g2(base, scalar)
+		}
+	}
+
+	type Bls12_381 = Bls12_381Host<Host>;
+	type G1Projective = G1ProjectiveHost<Host>;
+	type G2Projective = G2ProjectiveHost<Host>;
+	type G1Affine = G1AffineHost<Host>;
+	type G2Affine = G2AffineHost<Host>;
+
+	test_group!(g1; G1Projective; sw);
+	test_group!(g2; G2Projective; sw);
+	test_group!(pairing_output; PairingOutput<Bls12_381>; msm);
+	test_pairing!(ark_pairing; super::Bls12_381);
+
+	#[test]
+	fn test_g1_endomorphism_beta() {
+		assert!(sp_ark_bls12_381::g1::BETA.pow([3u64]).is_one());
+	}
+
+	#[test]
+	fn test_g1_subgroup_membership_via_endomorphism() {
+		let mut rng = test_rng();
+		let generator = G1Projective::rand(&mut rng).into_affine();
+		assert!(generator.is_in_correct_subgroup_assuming_on_curve());
+	}
+
+	#[test]
+	fn test_g1_subgroup_non_membership_via_endomorphism() {
+		let mut rng = test_rng();
+		loop {
+			let x = Fq::rand(&mut rng);
+			let greatest = rng.gen();
+
+			if let Some(p) = G1Affine::get_point_from_x_unchecked(x, greatest) {
+				if !<G1Projective as ark_std::Zero>::is_zero(&p.mul_bigint(Fr::characteristic())) {
+					assert!(!p.is_in_correct_subgroup_assuming_on_curve());
+					return
+				}
+			}
+		}
+	}
+
+	#[test]
+	fn test_g2_subgroup_membership_via_endomorphism() {
+		let mut rng = test_rng();
+		let generator = G2Projective::rand(&mut rng).into_affine();
+		assert!(generator.is_in_correct_subgroup_assuming_on_curve());
+	}
+
+	#[test]
+	fn test_g2_subgroup_non_membership_via_endomorphism() {
+		let mut rng = test_rng();
+		loop {
+			let x = Fq2::rand(&mut rng);
+			let greatest = rng.gen();
+
+			if let Some(p) = G2Affine::get_point_from_x_unchecked(x, greatest) {
+				if !<G2Projective as Zero>::is_zero(&p.mul_bigint(Fr::characteristic())) {
+					assert!(!p.is_in_correct_subgroup_assuming_on_curve());
+					return
+				}
+			}
+		}
+	}
+
+	// Test vectors and macro adapted from https://github.com/zkcrypto/bls12_381/blob/e224ad4ea1babfc582ccd751c2bf128611d10936/src/test-data/mod.rs
+	macro_rules! test_vectors {
+		($projective:ident, $affine:ident, $compress:expr, $expected:ident) => {
+			let mut e = $projective::zero();
+
+			let mut v = vec![];
+			{
+				let mut expected = $expected;
+				for _ in 0..1000 {
+					let e_affine = $affine::from(e);
+					let mut serialized = vec![0u8; e.serialized_size($compress)];
+					e_affine.serialize_with_mode(serialized.as_mut_slice(), $compress).unwrap();
+					v.extend_from_slice(&serialized[..]);
+
+					let mut decoded = serialized;
+					let len_of_encoding = decoded.len();
+					(&mut decoded[..]).copy_from_slice(&expected[0..len_of_encoding]);
+					expected = &expected[len_of_encoding..];
+					let decoded =
+						$affine::deserialize_with_mode(&decoded[..], $compress, Validate::Yes)
+							.unwrap();
+					assert_eq!(e_affine, decoded);
+
+					e += &$projective::generator();
+				}
+			}
+
+			assert_eq!(&v[..], $expected);
+		};
+	}
+
+	#[test]
+	fn g1_compressed_valid_test_vectors() {
+		let bytes: &'static [u8] = include_bytes!("test-data/g1_compressed_valid_test_vectors.dat");
+		test_vectors!(G1Projective, G1Affine, Compress::Yes, bytes);
+	}
+
+	#[test]
+	fn g1_uncompressed_valid_test_vectors() {
+		let bytes: &'static [u8] =
+			include_bytes!("test-data/g1_uncompressed_valid_test_vectors.dat");
+		test_vectors!(G1Projective, G1Affine, Compress::No, bytes);
+	}
+
+	#[test]
+	fn g2_compressed_valid_test_vectors() {
+		let bytes: &'static [u8] = include_bytes!("test-data/g2_compressed_valid_test_vectors.dat");
+		test_vectors!(G2Projective, G2Affine, Compress::Yes, bytes);
+	}
+
+	#[test]
+	fn g2_uncompressed_valid_test_vectors() {
+		let bytes: &'static [u8] =
+			include_bytes!("test-data/g2_uncompressed_valid_test_vectors.dat");
+		test_vectors!(G2Projective, G2Affine, Compress::No, bytes);
+	}
+}

substrate/primitives/crypto/ec-utils/src/bw6_761.rs

+// This file is part of Substrate.
+
+// Copyright (C) 2017-2022 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.
+
+//! Support functions for bw6_761 to improve the performance of
+//! multi_miller_loop, final_exponentiation, msm's and projective
+//! multiplications by host function calls.
+
+use crate::utils::{
+	final_exponentiation_generic, msm_sw_generic, mul_projective_generic, multi_miller_loop_generic,
+};
+use ark_bw6_761::{g1, g2, BW6_761};
+use sp_std::vec::Vec;
+
+/// Compute a multi miller loop through arkworks
+pub fn multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+	multi_miller_loop_generic::<BW6_761>(a, b)
+}
+
+/// Compute a final exponentiation through arkworks
+pub fn final_exponentiation(target: Vec<u8>) -> Result<Vec<u8>, ()> {
+	final_exponentiation_generic::<BW6_761>(target)
+}
+
+/// Compute a multi scalar multiplication for short_weierstrass through
+/// arkworks on G1.
+pub fn msm_g1(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_sw_generic::<g1::Config>(bases, scalars)
+}
+
+/// Compute a multi scalar multiplication for short_weierstrass through
+/// arkworks on G2.
+pub fn msm_g2(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_sw_generic::<g2::Config>(bases, scalars)
+}
+
+/// Compute a projective scalar multiplication for short_weierstrass through
+/// arkworks on G1.
+pub fn mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_generic::<g1::Config>(base, scalar)
+}
+
+/// Compute a projective scalar multiplication for short_weierstrass through
+/// arkworks on G2.
+pub fn mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_generic::<g2::Config>(base, scalar)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use ark_algebra_test_templates::*;
+	use sp_ark_bw6_761::{
+		G1Projective as G1ProjectiveHost, G2Projective as G2ProjectiveHost, HostFunctions,
+		BW6_761 as BW6_761Host,
+	};
+
+	#[derive(PartialEq, Eq)]
+	struct Host;
+
+	impl HostFunctions for Host {
+		fn bw6_761_multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bw6_761_multi_miller_loop(a, b)
+		}
+		fn bw6_761_final_exponentiation(f12: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bw6_761_final_exponentiation(f12)
+		}
+		fn bw6_761_msm_g1(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bw6_761_msm_g1(bases, bigints)
+		}
+		fn bw6_761_msm_g2(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bw6_761_msm_g2(bases, bigints)
+		}
+		fn bw6_761_mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bw6_761_mul_projective_g1(base, scalar)
+		}
+		fn bw6_761_mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bw6_761_mul_projective_g2(base, scalar)
+		}
+	}
+
+	type BW6_761 = BW6_761Host<Host>;
+	type G1Projective = G1ProjectiveHost<Host>;
+	type G2Projective = G2ProjectiveHost<Host>;
+
+	test_group!(g1; G1Projective; sw);
+	test_group!(g2; G2Projective; sw);
+	test_group!(pairing_output; ark_ec::pairing::PairingOutput<BW6_761>; msm);
+	test_pairing!(pairing; super::BW6_761);
+}

substrate/primitives/crypto/ec-utils/src/ed_on_bls12_377.rs

+// This file is part of Substrate.
+
+// Copyright (C) 2017-2022 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.
+
+//! Support functions for ed_on_bls12_377 to improve the performance of
+//! msm and projective multiplication by host function calls
+
+use crate::utils::{msm_te_generic, mul_projective_te_generic};
+use ark_ed_on_bls12_377::EdwardsConfig;
+use sp_std::vec::Vec;
+
+/// Compute a multi scalar mulitplication for twisted_edwards through
+/// arkworks.
+pub fn msm(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_te_generic::<EdwardsConfig>(bases, scalars)
+}
+
+/// Compute a projective scalar multiplication for twisted_edwards
+/// through arkworks.
+pub fn mul_projective(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_te_generic::<EdwardsConfig>(base, scalar)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use ark_algebra_test_templates::*;
+	use sp_ark_ed_on_bls12_377::{EdwardsProjective as EdwardsProjectiveHost, HostFunctions};
+
+	struct Host {}
+
+	impl HostFunctions for Host {
+		fn ed_on_bls12_377_msm(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::ed_on_bls12_377_msm(bases, scalars)
+		}
+		fn ed_on_bls12_377_mul_projective(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::ed_on_bls12_377_mul_projective(base, scalar)
+		}
+	}
+
+	type EdwardsProjective = EdwardsProjectiveHost<Host>;
+	test_group!(te; EdwardsProjective; te);
+}

substrate/primitives/crypto/ec-utils/src/ed_on_bls12_381_bandersnatch.rs

+// This file is part of Substrate.
+
+// Copyright (C) 2017-2022 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.
+
+//! Support functions for ed_on_bls12_381_bandersnatch to improve the
+//! performance of msm' and projective multiplications by host function
+//! calls.
+
+use crate::utils::{
+	msm_sw_generic, msm_te_generic, mul_projective_generic, mul_projective_te_generic,
+};
+use ark_ed_on_bls12_381_bandersnatch::BandersnatchConfig;
+use sp_std::vec::Vec;
+
+/// Compute a multi scalar multiplication for short_weierstrass through
+/// arkworks.
+pub fn sw_msm(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_sw_generic::<BandersnatchConfig>(bases, scalars)
+}
+
+/// Compute a multi scalar mulitplication for twisted_edwards through
+/// arkworks.
+pub fn te_msm(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_te_generic::<BandersnatchConfig>(bases, scalars)
+}
+
+/// Compute a projective scalar multiplication for short_weierstrass
+/// through arkworks.
+pub fn sw_mul_projective(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_generic::<BandersnatchConfig>(base, scalar)
+}
+
+/// Compute a projective scalar multiplication for twisted_edwards
+/// through arkworks.
+pub fn te_mul_projective(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_te_generic::<BandersnatchConfig>(base, scalar)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use ark_algebra_test_templates::*;
+	use sp_ark_ed_on_bls12_381_bandersnatch::{
+		EdwardsProjective as EdwardsProjectiveHost, HostFunctions, SWProjective as SWProjectiveHost,
+	};
+
+	pub struct Host {}
+
+	impl HostFunctions for Host {
+		fn ed_on_bls12_381_bandersnatch_te_msm(
+			bases: Vec<u8>,
+			scalars: Vec<u8>,
+		) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::ed_on_bls12_381_bandersnatch_te_msm(bases, scalars)
+		}
+		fn ed_on_bls12_381_bandersnatch_sw_msm(
+			bases: Vec<u8>,
+			scalars: Vec<u8>,
+		) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::ed_on_bls12_381_bandersnatch_sw_msm(bases, scalars)
+		}
+		fn ed_on_bls12_381_bandersnatch_te_mul_projective(
+			base: Vec<u8>,
+			scalar: Vec<u8>,
+		) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::ed_on_bls12_381_bandersnatch_te_mul_projective(base, scalar)
+		}
+		fn ed_on_bls12_381_bandersnatch_sw_mul_projective(
+			base: Vec<u8>,
+			scalar: Vec<u8>,
+		) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::ed_on_bls12_381_bandersnatch_sw_mul_projective(base, scalar)
+		}
+	}
+
+	type EdwardsProjective = EdwardsProjectiveHost<Host>;
+	type SWProjective = SWProjectiveHost<Host>;
+
+	test_group!(sw; SWProjective; sw);
+	test_group!(te; EdwardsProjective; te);
+}

substrate/primitives/crypto/ec-utils/src/lib.rs

+// 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.
+
+//! The main elliptic curves trait, allowing Substrate to call into host functions
+//! for operations on elliptic curves.
+
+#![warn(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub mod bls12_377;
+pub mod bls12_381;
+pub mod bw6_761;
+pub mod ed_on_bls12_377;
+pub mod ed_on_bls12_381_bandersnatch;
+mod utils;
+
+use sp_runtime_interface::runtime_interface;
+
+/// Interfaces for working with elliptic curves related types from within the runtime.
+/// All type are (de-)serialized through the wrapper types from the ark-scale trait,
+/// with ark_scale::{ArkScale, ArkScaleProjective};
+#[runtime_interface]
+pub trait EllipticCurves {
+	/// Compute a multi Miller loop for bls12_37
+	/// Receives encoded:
+	/// a: ArkScale<Vec<ark_ec::bls12::G1Prepared::<ark_bls12_377::Config>>>
+	/// b: ArkScale<Vec<ark_ec::bls12::G2Prepared::<ark_bls12_377::Config>>>
+	/// Returns encoded: ArkScale<MillerLoopOutput<Bls12<ark_bls12_377::Config>>>
+	fn bls12_377_multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_377::multi_miller_loop(a, b)
+	}
+
+	/// Compute a final exponentiation for bls12_377
+	/// Receives encoded: ArkScale<MillerLoopOutput<Bls12<ark_bls12_377::Config>>>
+	/// Returns encoded: ArkScale<PairingOutput<Bls12<ark_bls12_377::Config>>>
+	fn bls12_377_final_exponentiation(f12: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_377::final_exponentiation(f12)
+	}
+
+	/// Compute a projective multiplication on G1 for bls12_377
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_bls12_377::G1Projective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_377::G1Projective>
+	fn bls12_377_mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_377::mul_projective_g1(base, scalar)
+	}
+
+	/// Compute a projective multiplication on G2 for bls12_377
+	/// through arkworks on G2
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_bls12_377::G2Projective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_377::G2Projective>
+	fn bls12_377_mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_377::mul_projective_g2(base, scalar)
+	}
+
+	/// Compute a msm on G1 for bls12_377
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_bls12_377::G1Affine]>
+	/// scalars: ArkScale<&[ark_bls12_377::Fr]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_377::G1Projective>
+	fn bls12_377_msm_g1(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_377::msm_g1(bases, scalars)
+	}
+
+	/// Compute a msm on G2 for bls12_377
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_bls12_377::G2Affine]>
+	/// scalars: ArkScale<&[ark_bls12_377::Fr]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_377::G2Projective>
+	fn bls12_377_msm_g2(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_377::msm_g2(bases, scalars)
+	}
+
+	/// Compute a multi Miller loop on bls12_381
+	/// Receives encoded:
+	/// a: ArkScale<Vec<ark_ec::bls12::G1Prepared::<ark_bls12_381::Config>>>
+	/// b: ArkScale<Vec<ark_ec::bls12::G2Prepared::<ark_bls12_381::Config>>>
+	/// Returns encoded: ArkScale<MillerLoopOutput<Bls12<ark_bls12_381::Config>>>
+	fn bls12_381_multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_381::multi_miller_loop(a, b)
+	}
+
+	/// Compute a final exponentiation on bls12_381
+	/// Receives encoded: ArkScale<MillerLoopOutput<Bls12<ark_bls12_381::Config>>>
+	/// Returns encoded:ArkScale<PairingOutput<Bls12<ark_bls12_381::Config>>>
+	fn bls12_381_final_exponentiation(f12: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_381::final_exponentiation(f12)
+	}
+
+	/// Compute a projective multiplication on G1 for bls12_381
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_bls12_381::G1Projective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_381::G1Projective>
+	fn bls12_381_mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_381::mul_projective_g1(base, scalar)
+	}
+
+	/// Compute a projective multiplication on G2 for bls12_381
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_bls12_381::G2Projective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_381::G2Projective>
+	fn bls12_381_mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_381::mul_projective_g2(base, scalar)
+	}
+
+	/// Compute a msm on G1 for bls12_381
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_bls12_381::G1Affine]>
+	/// scalars: ArkScale<&[ark_bls12_381::Fr]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_381::G1Projective>
+	fn bls12_381_msm_g1(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_381::msm_g1(bases, scalars)
+	}
+
+	/// Compute a msm on G2 for bls12_381
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_bls12_381::G2Affine]>
+	/// scalars: ArkScale<&[ark_bls12_381::Fr]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_381::G2Projective>
+	fn bls12_381_msm_g2(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_381::msm_g2(bases, scalars)
+	}
+
+	/// Compute a multi Miller loop on bw6_761
+	/// Receives encoded:
+	/// a: ArkScale<Vec<ark_ec::bw6::G1Prepared::<ark_bw6_761::Config>>>
+	/// b: ArkScale<Vec<ark_ec::bw6::G2Prepared::<ark_bw6_761::Config>>>
+	/// Returns encoded: ArkScale<MillerLoopOutput<Bls12<ark_bw6_761::Config>>>
+	fn bw6_761_multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bw6_761::multi_miller_loop(a, b)
+	}
+
+	/// Compute a final exponentiation on bw6_761
+	/// Receives encoded: ArkScale<MillerLoopOutput<BW6<ark_bw6_761::Config>>>
+	/// Returns encoded: ArkScale<PairingOutput<BW6<ark_bw6_761::Config>>>
+	fn bw6_761_final_exponentiation(f12: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bw6_761::final_exponentiation(f12)
+	}
+
+	/// Compute a projective multiplication on G1 for bw6_761
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_bw6_761::G1Projective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_bw6_761::G1Projective>
+	fn bw6_761_mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bw6_761::mul_projective_g1(base, scalar)
+	}
+
+	/// Compute a projective multiplication on G2 for bw6_761
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_bw6_761::G2Projective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_bw6_761::G2Projective>
+	fn bw6_761_mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bw6_761::mul_projective_g2(base, scalar)
+	}
+
+	/// Compute a msm on G1 for bw6_761
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_bw6_761::G1Affine]>
+	/// scalars: ArkScale<&[ark_bw6_761::Fr]>
+	/// Returns encoded: ArkScaleProjective<ark_bw6_761::G1Projective>
+	fn bw6_761_msm_g1(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bw6_761::msm_g1(bases, bigints)
+	}
+
+	/// Compute a msm on G2 for bw6_761
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_bw6_761::G2Affine]>
+	/// scalars: ArkScale<&[ark_bw6_761::Fr]>
+	/// Returns encoded: ArkScaleProjective<ark_bw6_761::G2Projective>
+	fn bw6_761_msm_g2(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bw6_761::msm_g2(bases, bigints)
+	}
+
+	/// Compute projective multiplication on ed_on_bls12_377
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_ed_on_bls12_377::EdwardsProjective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_ed_on_bls12_377::EdwardsProjective>
+	fn ed_on_bls12_377_mul_projective(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+		ed_on_bls12_377::mul_projective(base, scalar)
+	}
+
+	/// Compute msm on ed_on_bls12_377
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_ed_on_bls12_377::EdwardsAffine]>
+	/// scalars:
+	/// ArkScale<&[ark_ed_on_bls12_377::Fr]>
+	/// Returns encoded:
+	/// ArkScaleProjective<ark_ed_on_bls12_377::EdwardsProjective>
+	fn ed_on_bls12_377_msm(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+		ed_on_bls12_377::msm(bases, scalars)
+	}
+
+	/// Compute short weierstrass projective multiplication on ed_on_bls12_381_bandersnatch
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_ed_on_bls12_381_bandersnatch::SWProjective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_ed_on_bls12_381_bandersnatch::SWProjective>
+	fn ed_on_bls12_381_bandersnatch_sw_mul_projective(
+		base: Vec<u8>,
+		scalar: Vec<u8>,
+	) -> Result<Vec<u8>, ()> {
+		ed_on_bls12_381_bandersnatch::sw_mul_projective(base, scalar)
+	}
+
+	/// Compute twisted edwards projective multiplication on ed_on_bls12_381_bandersnatch
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_ed_on_bls12_381_bandersnatch::EdwardsProjective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_ed_on_bls12_381_bandersnatch::EdwardsProjective>
+	fn ed_on_bls12_381_bandersnatch_te_mul_projective(
+		base: Vec<u8>,
+		scalar: Vec<u8>,
+	) -> Result<Vec<u8>, ()> {
+		ed_on_bls12_381_bandersnatch::te_mul_projective(base, scalar)
+	}
+
+	/// Compute short weierstrass msm on ed_on_bls12_381_bandersnatch
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_ed_on_bls12_381_bandersnatch::SWAffine]>
+	/// scalars: ArkScale<&[ark_ed_on_bls12_381_bandersnatch::Fr]>
+	/// Returns encoded:
+	/// ArkScaleProjective<ark_ed_on_bls12_381_bandersnatch::SWProjective>
+	fn ed_on_bls12_381_bandersnatch_sw_msm(
+		bases: Vec<u8>,
+		scalars: Vec<u8>,
+	) -> Result<Vec<u8>, ()> {
+		ed_on_bls12_381_bandersnatch::sw_msm(bases, scalars)
+	}
+
+	/// Compute twisted edwards msm on ed_on_bls12_381_bandersnatch
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_ed_on_bls12_381_bandersnatch::EdwardsProjective>
+	/// scalars: ArkScale<&[ark_ed_on_bls12_381_bandersnatch::Fr]>
+	/// Returns encoded:
+	/// ArkScaleProjective<ark_ed_on_bls12_381_bandersnatch::EdwardsProjective>
+	fn ed_on_bls12_381_bandersnatch_te_msm(
+		bases: Vec<u8>,
+		scalars: Vec<u8>,
+	) -> Result<Vec<u8>, ()> {
+		ed_on_bls12_381_bandersnatch::te_msm(bases, scalars)
+	}
+}

substrate/primitives/crypto/ec-utils/src/utils.rs

+// 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.
+
+//! The generic executions of the operations on arkworks elliptic curves
+//! which get instantiatied by the corresponding curves.
+use ark_ec::{
+	pairing::{MillerLoopOutput, Pairing, PairingOutput},
+	short_weierstrass,
+	short_weierstrass::SWCurveConfig,
+	twisted_edwards,
+	twisted_edwards::TECurveConfig,
+	CurveConfig, VariableBaseMSM,
+};
+use ark_scale::hazmat::ArkScaleProjective;
+use ark_std::vec::Vec;
+use codec::{Decode, Encode};
+
+const HOST_CALL: ark_scale::Usage = ark_scale::HOST_CALL;
+type ArkScale<T> = ark_scale::ArkScale<T, HOST_CALL>;
+
+pub(crate) fn multi_miller_loop_generic<Curve: Pairing>(
+	g1: Vec<u8>,
+	g2: Vec<u8>,
+) -> Result<Vec<u8>, ()> {
+	let g1 = <ArkScale<Vec<<Curve as Pairing>::G1Affine>> as Decode>::decode(&mut g1.as_slice())
+		.map_err(|_| ())?;
+	let g2 = <ArkScale<Vec<<Curve as Pairing>::G2Affine>> as Decode>::decode(&mut g2.as_slice())
+		.map_err(|_| ())?;
+
+	let result = Curve::multi_miller_loop(g1.0, g2.0).0;
+
+	let result: ArkScale<<Curve as Pairing>::TargetField> = result.into();
+	Ok(result.encode())
+}
+
+pub(crate) fn final_exponentiation_generic<Curve: Pairing>(target: Vec<u8>) -> Result<Vec<u8>, ()> {
+	let target =
+		<ArkScale<<Curve as Pairing>::TargetField> as Decode>::decode(&mut target.as_slice())
+			.map_err(|_| ())?;
+
+	let result = Curve::final_exponentiation(MillerLoopOutput(target.0)).ok_or(())?;
+
+	let result: ArkScale<PairingOutput<Curve>> = result.into();
+	Ok(result.encode())
+}
+
+pub(crate) fn msm_sw_generic<Curve: SWCurveConfig>(
+	bases: Vec<u8>,
+	scalars: Vec<u8>,
+) -> Result<Vec<u8>, ()> {
+	let bases =
+		<ArkScale<Vec<short_weierstrass::Affine<Curve>>> as Decode>::decode(&mut bases.as_slice())
+			.map_err(|_| ())?;
+	let scalars = <ArkScale<Vec<<Curve as CurveConfig>::ScalarField>> as Decode>::decode(
+		&mut scalars.as_slice(),
+	)
+	.map_err(|_| ())?;
+
+	let result =
+		<short_weierstrass::Projective<Curve> as VariableBaseMSM>::msm(&bases.0, &scalars.0)
+			.map_err(|_| ())?;
+
+	let result: ArkScaleProjective<short_weierstrass::Projective<Curve>> = result.into();
+	Ok(result.encode())
+}
+
+pub(crate) fn msm_te_generic<Curve: TECurveConfig>(
+	bases: Vec<u8>,
+	scalars: Vec<u8>,
+) -> Result<Vec<u8>, ()> {
+	let bases =
+		<ArkScale<Vec<twisted_edwards::Affine<Curve>>> as Decode>::decode(&mut bases.as_slice())
+			.map_err(|_| ())?;
+	let scalars = <ArkScale<Vec<<Curve as CurveConfig>::ScalarField>> as Decode>::decode(
+		&mut scalars.as_slice(),
+	)
+	.map_err(|_| ())?;
+
+	let result = <twisted_edwards::Projective<Curve> as VariableBaseMSM>::msm(&bases.0, &scalars.0)
+		.map_err(|_| ())?;
+
+	let result: ArkScaleProjective<twisted_edwards::Projective<Curve>> = result.into();
+	Ok(result.encode())
+}
+
+pub(crate) fn mul_projective_generic<Group: SWCurveConfig>(
+	base: Vec<u8>,
+	scalar: Vec<u8>,
+) -> Result<Vec<u8>, ()> {
+	let base = <ArkScaleProjective<short_weierstrass::Projective<Group>> as Decode>::decode(
+		&mut base.as_slice(),
+	)
+	.map_err(|_| ())?;
+	let scalar = <ArkScale<Vec<u64>> as Decode>::decode(&mut scalar.as_slice()).map_err(|_| ())?;
+
+	let result = <Group as SWCurveConfig>::mul_projective(&base.0, &scalar.0);
+
+	let result: ArkScaleProjective<short_weierstrass::Projective<Group>> = result.into();
+	Ok(result.encode())
+}
+
+pub(crate) fn mul_projective_te_generic<Group: TECurveConfig>(
+	base: Vec<u8>,
+	scalar: Vec<u8>,
+) -> Result<Vec<u8>, ()> {
+	let base = <ArkScaleProjective<twisted_edwards::Projective<Group>> as Decode>::decode(
+		&mut base.as_slice(),
+	)
+	.map_err(|_| ())?;
+	let scalar = <ArkScale<Vec<u64>> as Decode>::decode(&mut scalar.as_slice()).map_err(|_| ())?;
+
+	let result = <Group as TECurveConfig>::mul_projective(&base.0, &scalar.0);
+
+	let result: ArkScaleProjective<twisted_edwards::Projective<Group>> = result.into();
+	Ok(result.encode())
+}