Merge branch 'master' into AndreiEres/flaky-zombie-statement

Author: AndreiEres

Cargo.lock

@@ -645,6 +645,7 @@ bitvec = { version = "1.0.1", default-features = false }
 blake2 = { version = "0.10.4", default-features = false }
 blake2b_simd = { version = "1.0.2", default-features = false }
 blake3 = { version = "1.5" }
+bn = { package = "substrate-bn", version = "0.6", default-features = false }
 bounded-collections = { version = "0.2.3", default-features = false }
 bounded-vec = { version = "0.7" }
 bp-asset-hub-rococo = { path = "bridges/chains/chain-asset-hub-rococo", default-features = false }
@@ -888,8 +889,9 @@ node-rpc = { path = "substrate/bin/node/rpc" }
 node-testing = { path = "substrate/bin/node/testing" }
 nohash-hasher = { version = "0.2.0" }
 novelpoly = { version = "2.0.0", package = "reed-solomon-novelpoly" }
-num-bigint = { version = "0.4.3" }
+num-bigint = { version = "0.4.3", default-features = false }
 num-format = { version = "0.4.3" }
+num-integer = { version = "0.1.46", default-features = false }
 num-rational = { version = "0.4.1" }
 num-traits = { version = "0.2.17", default-features = false }
 num_cpus = { version = "1.13.1" }
@@ -1137,6 +1139,7 @@ relay-substrate-client = { path = "bridges/relays/client-substrate" }
 relay-utils = { path = "bridges/relays/utils" }
 remote-externalities = { path = "substrate/utils/frame/remote-externalities", default-features = false, package = "frame-remote-externalities" }
 reqwest = { version = "0.12.9", default-features = false }
+ripemd = { version = "0.1.3", default-features = false }
 rlp = { version = "0.6.1", default-features = false }
 rococo-emulated-chain = { path = "cumulus/parachains/integration-tests/emulated/chains/relays/rococo" }
 rococo-parachain-runtime = { path = "cumulus/parachains/runtimes/testing/rococo-parachain" }

Cargo.toml

@@ -398,7 +398,7 @@ where
 			aura_internal::seal::<_, P>(&pre_hash, &author_pub, keystore).map_err(Box::new)?;
 		let mut block_import_params = BlockImportParams::new(BlockOrigin::Own, pre_header);
 		block_import_params.post_digests.push(seal_digest);
-		block_import_params.body = Some(body.clone());
+		block_import_params.body = Some(body);
 		block_import_params.state_action =
 			StateAction::ApplyChanges(sc_consensus::StorageChanges::Changes(storage_changes));
 		block_import_params.fork_choice = Some(ForkChoiceStrategy::LongestChain);

cumulus/client/consensus/aura/src/collator.rs

@@ -0,0 +1,11 @@
+title: '[pallet-revive] precompiles 2->9'
+doc:
+- audience: Runtime Dev
+  description: Add missing pre-compiles 02 -> 09
+crates:
+- name: pallet-revive
+  bump: patch
+- name: pallet-revive-fixtures
+  bump: patch
+- name: pallet-revive-uapi
+  bump: patch

prdoc/pr_7810.prdoc

@@ -141,7 +141,7 @@ where
 		})?;
 
 	let signature = signature
-		.clone()
+		.as_slice()
 		.try_into()
 		.map_err(|_| ConsensusError::InvalidSignature(signature, public.to_raw_vec()))?;
 

substrate/client/consensus/aura/src/standalone.rs

@@ -26,6 +26,9 @@ ethereum-types = { workspace = true, features = ["codec", "rlp", "serialize"] }
 hex-literal = { workspace = true }
 impl-trait-for-tuples = { workspace = true }
 log = { workspace = true }
+num-bigint = { workspace = true }
+num-integer = { workspace = true }
+num-traits = { workspace = true }
 paste = { workspace = true }
 polkavm = { version = "0.21.0", default-features = false }
 polkavm-common = { version = "0.21.0", default-features = false, optional = true }
@@ -39,13 +42,15 @@ serde = { features = [
 ], workspace = true, default-features = false }
 
 # Polkadot SDK Dependencies
+bn = { workspace = true }
 frame-benchmarking = { optional = true, workspace = true }
 frame-support = { workspace = true }
 frame-system = { workspace = true }
 pallet-revive-fixtures = { workspace = true, optional = true }
 pallet-revive-proc-macro = { workspace = true }
 pallet-revive-uapi = { workspace = true, features = ["scale"] }
 pallet-transaction-payment = { workspace = true }
+ripemd = { workspace = true }
 sp-api = { workspace = true }
 sp-arithmetic = { workspace = true }
 sp-consensus-aura = { workspace = true, optional = true }
@@ -89,6 +94,9 @@ std = [
 	"frame-support/std",
 	"frame-system/std",
 	"log/std",
+	"num-bigint/std",
+	"num-integer/std",
+	"num-traits/std",
 	"pallet-proxy/std",
 	"pallet-revive-fixtures?/std",
 	"pallet-timestamp/std",
@@ -97,6 +105,7 @@ std = [
 	"polkavm-common?/std",
 	"polkavm/std",
 	"rand?/std",
+	"ripemd/std",
 	"rlp/std",
 	"scale-info/std",
 	"secp256k1/std",

substrate/frame/revive/Cargo.toml

@@ -30,14 +30,14 @@ pub extern "C" fn deploy() {}
 #[polkavm_derive::polkavm_export]
 pub extern "C" fn call() {
 	input!(
-		256,
+		512,
 		callee_addr: &[u8; 20],
 		value: u64,
 		callee_input: [u8],
 	);
 
 	// Call the callee
-	let mut output = [0u8; 32];
+	let mut output = [0u8; 512];
 	let output = &mut &mut output[..];
 
 	match api::call(

substrate/frame/revive/fixtures/contracts/call_and_return.rs

@@ -43,10 +43,9 @@ pub extern "C" fn deploy() {}
 ///
 /// | value | Algorithm | Bit Width |
 /// |-------|-----------|-----------|
-/// |     0 |      SHA2 |       256 |
-/// |     1 |    KECCAK |       256 |
-/// |     2 |    BLAKE2 |       256 |
-/// |     3 |    BLAKE2 |       128 |
+/// |     2 |    KECCAK |       256 |
+/// |     3 |    BLAKE2 |       256 |
+/// |     4 |    BLAKE2 |       128 |
 /// ---------------------------------
 
 #[no_mangle]
@@ -59,11 +58,6 @@ pub extern "C" fn call() {
 	);
 
 	match chosen_hash_fn {
-		1 => {
-			let mut output = [0u8; 32];
-			api::hash_sha2_256(input, &mut output);
-			api::return_value(uapi::ReturnFlags::empty(), &output);
-		},
 		2 => {
 			let mut output = [0u8; 32];
 			api::hash_keccak_256(input, &mut output);

substrate/frame/revive/fixtures/contracts/crypto_hashes.rs

@@ -1854,16 +1854,50 @@ mod benchmarks {
 
 	// `n`: Input to hash in bytes
 	#[benchmark(pov_mode = Measured)]
-	fn seal_hash_sha2_256(n: Linear<0, { limits::code::BLOB_BYTES }>) {
-		build_runtime!(runtime, memory: [[0u8; 32], vec![0u8; n as usize], ]);
+	fn sha2_256(n: Linear<0, { limits::code::BLOB_BYTES }>) {
+		let input = vec![0u8; n as usize];
+		let mut call_setup = CallSetup::<T>::default();
+		let (mut ext, _) = call_setup.ext();
 
 		let result;
 		#[block]
 		{
-			result = runtime.bench_hash_sha2_256(memory.as_mut_slice(), 32, n, 0);
+			result = pure_precompiles::Sha256::execute(ext.gas_meter_mut(), &input);
 		}
-		assert_eq!(sp_io::hashing::sha2_256(&memory[32..]), &memory[0..32]);
-		assert_ok!(result);
+		assert_eq!(sp_io::hashing::sha2_256(&input).to_vec(), result.unwrap().data);
+	}
+
+	#[benchmark(pov_mode = Measured)]
+	fn identity(n: Linear<0, { limits::code::BLOB_BYTES }>) {
+		let input = vec![0u8; n as usize];
+		let mut call_setup = CallSetup::<T>::default();
+		let (mut ext, _) = call_setup.ext();
+
+		let result;
+		#[block]
+		{
+			result = pure_precompiles::Identity::execute(ext.gas_meter_mut(), &input);
+		}
+		assert_eq!(input, result.unwrap().data);
+	}
+
+	// `n`: Input to hash in bytes
+	#[benchmark(pov_mode = Measured)]
+	fn ripemd_160(n: Linear<0, { limits::code::BLOB_BYTES }>) {
+		use ripemd::Digest;
+		let input = vec![0u8; n as usize];
+		let mut call_setup = CallSetup::<T>::default();
+		let (mut ext, _) = call_setup.ext();
+
+		let result;
+		#[block]
+		{
+			result = pure_precompiles::Ripemd160::execute(ext.gas_meter_mut(), &input);
+		}
+		let mut expected = [0u8; 32];
+		expected[12..32].copy_from_slice(&ripemd::Ripemd160::digest(input));
+
+		assert_eq!(expected.to_vec(), result.unwrap().data);
 	}
 
 	// `n`: Input to hash in bytes
@@ -1957,6 +1991,74 @@ mod benchmarks {
 		assert_eq!(result.unwrap().data, expected);
 	}
 
+	#[benchmark(pov_mode = Measured)]
+	fn bn128_add() {
+		use hex_literal::hex;
+		let input = hex!("089142debb13c461f61523586a60732d8b69c5b38a3380a74da7b2961d867dbf2d5fc7bbc013c16d7945f190b232eacc25da675c0eb093fe6b9f1b4b4e107b3625f8c89ea3437f44f8fc8b6bfbb6312074dc6f983809a5e809ff4e1d076dd5850b38c7ced6e4daef9c4347f370d6d8b58f4b1d8dc61a3c59d651a0644a2a27cf");
+		let expected = hex!("0a6678fd675aa4d8f0d03a1feb921a27f38ebdcb860cc083653519655acd6d79172fd5b3b2bfdd44e43bcec3eace9347608f9f0a16f1e184cb3f52e6f259cbeb");
+		let mut call_setup = CallSetup::<T>::default();
+		let (mut ext, _) = call_setup.ext();
+
+		let result;
+
+		#[block]
+		{
+			result = pure_precompiles::Bn128Add::execute(ext.gas_meter_mut(), &input);
+		}
+
+		assert_eq!(result.unwrap().data, expected);
+	}
+
+	#[benchmark(pov_mode = Measured)]
+	fn bn128_mul() {
+		use hex_literal::hex;
+		let input = hex!("089142debb13c461f61523586a60732d8b69c5b38a3380a74da7b2961d867dbf2d5fc7bbc013c16d7945f190b232eacc25da675c0eb093fe6b9f1b4b4e107b36ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+		let expected = hex!("0bf982b98a2757878c051bfe7eee228b12bc69274b918f08d9fcb21e9184ddc10b17c77cbf3c19d5d27e18cbd4a8c336afb488d0e92c18d56e64dd4ea5c437e6");
+		let mut call_setup = CallSetup::<T>::default();
+		let (mut ext, _) = call_setup.ext();
+
+		let result;
+
+		#[block]
+		{
+			result = pure_precompiles::Bn128Mul::execute(ext.gas_meter_mut(), &input);
+		}
+
+		assert_eq!(result.unwrap().data, expected);
+	}
+
+	// `n`: pairings to perform
+	#[benchmark(pov_mode = Measured)]
+	fn bn128_pairing(n: Linear<0, { limits::code::BLOB_BYTES / 192 }>) {
+		let input = pure_precompiles::generate_random_ecpairs(n as usize);
+		let mut call_setup = CallSetup::<T>::default();
+		let (mut ext, _) = call_setup.ext();
+
+		let result;
+		#[block]
+		{
+			result = pure_precompiles::Bn128Pairing::execute(ext.gas_meter_mut(), &input);
+		}
+		assert_ok!(result);
+	}
+
+	// `n`: number of rounds to perform
+	#[benchmark(pov_mode = Measured)]
+	fn blake2f(n: Linear<0, 1200>) {
+		use hex_literal::hex;
+		let input = hex!("48c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b61626300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000001");
+		let input = n.to_be_bytes().to_vec().into_iter().chain(input.to_vec()).collect::<Vec<_>>();
+		let mut call_setup = CallSetup::<T>::default();
+		let (mut ext, _) = call_setup.ext();
+
+		let result;
+		#[block]
+		{
+			result = pure_precompiles::Blake2F::execute(ext.gas_meter_mut(), &input);
+		}
+		assert_ok!(result);
+	}
+
 	// Only calling the function itself for the list of
 	// generated different ECDSA keys.
 	// This is a slow call: We reduce the number of runs.

substrate/frame/revive/src/benchmarking/mod.rs

@@ -495,6 +495,8 @@ pub mod pallet {
 		RefcountOverOrUnderflow,
 		/// Unsupported precompile address
 		UnsupportedPrecompileAddress,
+		/// Precompile Error
+		PrecompileFailure,
 	}
 
 	/// A reason for the pallet contracts placing a hold on funds.