wip

frame/contracts/fixtures/sr25519_verify.wat

@@ -29,18 +29,19 @@
 	(func (export "call")
 		;; define local variables
 		(local $signature_ptr i32)
-		(local $message_ptr i32)
 		(local $pub_key_ptr i32)
+		(local $message_len i32)
+		(local $message_ptr i32)
 		(local $result i32)
 
 		;; set the pointers to the memory locations
 		;; Memory layout during `call`
 		;; [10, 74) signature
-		;; [74, 86) message
-		;; [86, 118) public key
+		;; [74, 106) public key
+		;; [106, 118) message (12 bytes)
 		(local.set $signature_ptr (i32.const 10))
-		(local.set $message_ptr (i32.const 74))
-		(local.set $pub_key_ptr (i32.const 86))
+		(local.set $pub_key_ptr (i32.const 74))
+		(local.set $message_ptr (i32.const 106))
 
 		;; store the input into the memory, starting at the signature and 
 		;; up to 108 bytes stored at offset 4
@@ -51,9 +52,9 @@
 			$result
 			(call $seal_sr25519_verify
 				(local.get $signature_ptr)
-				(local.get $message_ptr)
-				(i32.const 12)
 				(local.get $pub_key_ptr)
+				(i32.const 12)
+				(local.get $message_ptr)
 			)
 		)
 

frame/contracts/src/benchmarking/mod.rs

@@ -2020,9 +2020,61 @@ benchmarks! {
 		let origin = RawOrigin::Signed(instance.caller.clone());
 	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
 
+	// `n`: Messaqe input to verify in bytes
+	#[pov_mode = Measured]
+	seal_sr25519_verify {
+		let n in 0 .. T::MaxCodeLen::get() - 255; // need some buffer so the code size does not
+												  // exceed the max code size.
+
+		let message = (0..n).zip((32u8..127u8).cycle()).map(|(_, c)| c).collect::<Vec<_>>().encode();
+		let message_len = message.len() as i32;
+
+		let key_type = sp_core::crypto::KeyTypeId(*b"code");
+		let pub_key = sp_io::crypto::sr25519_generate(key_type, None);
+		let sig = sp_io::crypto::sr25519_sign(key_type, &pub_key, &message).expect("Generates signature");
+		let sig = AsRef::<[u8; 64]>::as_ref(&sig).to_vec();
+
+		let code = WasmModule::<T>::from(ModuleDefinition {
+			memory: Some(ImportedMemory::max::<T>()),
+			imported_functions: vec![ImportedFunction {
+				module: "seal0",
+				name: "seal_sr25519_verify",
+				params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
+				return_type: Some(ValueType::I32),
+			}],
+			data_segments: vec![
+				DataSegment {
+					offset: 0,
+					value: sig,
+				},
+				DataSegment {
+					offset: 64,
+					value: pub_key.to_vec(),
+				},
+				DataSegment {
+					offset: 96,
+					value: message,
+				},
+			],
+			call_body: Some(body::plain(vec![
+				Instruction::I32Const(0), // signature_ptr
+				Instruction::I32Const(64), // pub_key_ptr
+				Instruction::I32Const(message_len), // message_len
+				Instruction::I32Const(96), // message_ptr
+				Instruction::Call(0),
+				Instruction::Drop,
+				Instruction::End,
+			])),
+			.. Default::default()
+		});
+
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
 	// Only calling the function itself with valid arguments.
 	// It generates different private keys and signatures for the message "Hello world".
-	// This is a slow call: We redeuce the number of runs.
+	// This is a slow call: We reduce the number of runs.
 	#[pov_mode = Measured]
 	seal_ecdsa_recover {
 		let r in 0 .. API_BENCHMARK_RUNS / 10;

frame/contracts/src/exec.rs

@@ -39,10 +39,7 @@ use sp_core::{
 	ecdsa::Public as ECDSAPublic,
 	sr25519::{Public as SR25519Public, Signature as SR25519Signature},
 };
-use sp_io::{
-	crypto::{secp256k1_ecdsa_recover_compressed, sr25519_verify as crypto_sr25519_verify},
-	hashing::blake2_256,
-};
+use sp_io::{crypto::secp256k1_ecdsa_recover_compressed, hashing::blake2_256};
 use sp_runtime::traits::{Convert, Hash};
 use sp_std::{marker::PhantomData, mem, prelude::*, vec::Vec};
 
@@ -1357,7 +1354,11 @@ where
 	}
 
 	fn sr25519_verify(&self, signature: &[u8; 64], message: &[u8], pub_key: &[u8; 32]) -> bool {
-		crypto_sr25519_verify(&SR25519Signature(*signature), message, &SR25519Public(*pub_key))
+		sp_io::crypto::sr25519_verify(
+			&SR25519Signature(*signature),
+			message,
+			&SR25519Public(*pub_key),
+		)
 	}
 
 	fn ecdsa_to_eth_address(&self, pk: &[u8; 33]) -> Result<[u8; 20], ()> {

frame/contracts/src/tests.rs

@@ -2947,8 +2947,8 @@ fn sr25519_verify() {
 
 			let mut params = vec![];
 			params.extend_from_slice(&signature);
-			params.extend_from_slice(&message.to_vec().encode());
 			params.extend_from_slice(&public_key);
+			params.extend_from_slice(&message.to_vec().encode());
 
 			<Pallet<Test>>::bare_call(
 				ALICE,

frame/contracts/src/wasm/runtime.rs

@@ -253,7 +253,7 @@ pub enum RuntimeCosts {
 	/// Weight of calling `seal_ecdsa_recover`.
 	EcdsaRecovery,
 	/// Weight of calling `seal_sr25519_verify`.
-	Sr25519Verify,
+	Sr25519Verify(u32),
 	/// Weight charged by a chain extension through `seal_call_chain_extension`.
 	ChainExtension(Weight),
 	/// Weight charged for calling into the runtime.
@@ -276,6 +276,7 @@ impl RuntimeCosts {
 		let weight = match *self {
 			MeteringBlock(amount) => s.gas.saturating_add(Weight::from_parts(amount, 0)),
 			CopyFromContract(len) => s.return_per_byte.saturating_mul(len.into()),
+			Sr25519Verify(len) => s.sr25519_verify.saturating_mul(len.into()),
 			CopyToContract(len) => s.input_per_byte.saturating_mul(len.into()),
 			Caller => s.caller,
 			IsContract => s.is_contract,
@@ -339,7 +340,6 @@ impl RuntimeCosts {
 				.hash_blake2_128
 				.saturating_add(s.hash_blake2_128_per_byte.saturating_mul(len.into())),
 			EcdsaRecovery => s.ecdsa_recover,
-			Sr25519Verify => s.sr25519_verify,
 			ChainExtension(weight) => weight,
 			CallRuntime(weight) => weight,
 			SetCodeHash => s.set_code_hash,
@@ -2476,11 +2476,11 @@ pub mod env {
 	///
 	/// - `signature_ptr`: the pointer into the linear memory where the signature is placed. Should
 	///   be decodable as a 64 bytes. Traps otherwise.
-	/// - `message_ptr`: the pointer into the linear memory where the message is placed.
-	/// - `message_len`: the length of the message payload. Should be decodable as a Scale encoded
-	///   Vec<u8>. Traps otherwise.
 	/// - `pub_key_ptr`: the pointer into the linear memory where the public key is placed. Should
 	///   be decodable as a 32 bytes. Traps otherwise.
+	/// - `message_len`: the length of the message payload.
+	/// - `message_ptr`: the pointer into the linear memory where the message is placed. Should be
+	///   decodable as a Scale encoded Vec<u8>. Traps otherwise
 	/// # Errors
 	///
 	/// - `ReturnCode::Sr25519VerifyFailed
@@ -2490,17 +2490,21 @@ pub mod env {
 		ctx: _,
 		memory: _,
 		signature_ptr: u32,
-		message_ptr: u32,
-		message_len: u32,
 		pub_key_ptr: u32,
+		message_len: u32,
+		message_ptr: u32,
 	) -> Result<ReturnCode, TrapReason> {
-		ctx.charge_gas(RuntimeCosts::Sr25519Verify)?;
+		ctx.charge_gas(RuntimeCosts::Sr25519Verify(message_len))?;
+
 		let mut signature: [u8; 64] = [0; 64];
 		ctx.read_sandbox_memory_into_buf(memory, signature_ptr, &mut signature)?;
+
 		let mut pub_key: [u8; 32] = [0; 32];
 		ctx.read_sandbox_memory_into_buf(memory, pub_key_ptr, &mut pub_key)?;
+
 		let message: Vec<u8> =
 			ctx.read_sandbox_memory_as_unbounded(memory, message_ptr, message_len)?;
+
 		if ctx.ext.sr25519_verify(&signature, &message, &pub_key) {
 			Ok(ReturnCode::Success)
 		} else {