From b3ab312724ee8c3a0c7f3d9b5ea6c98513b5c951 Mon Sep 17 00:00:00 2001
From: Xavier Lau <xavier@inv.cafe>
Date: Fri, 29 Nov 2024 20:02:59 +0800
Subject: [PATCH 1/5] Migrate pallet-preimage to benchmark v2 (#6277)

Part of:

- #6202.

---------

Co-authored-by: Giuseppe Re <giuseppe.re@parity.io>
Co-authored-by: command-bot <>
---
 substrate/frame/preimage/src/benchmarking.rs | 296 ++++++++++---------
 substrate/frame/preimage/src/weights.rs      | 150 +++++-----
 2 files changed, 231 insertions(+), 215 deletions(-)

diff --git a/substrate/frame/preimage/src/benchmarking.rs b/substrate/frame/preimage/src/benchmarking.rs
index 3d0c5b900579..ea635bf3ef77 100644
--- a/substrate/frame/preimage/src/benchmarking.rs
+++ b/substrate/frame/preimage/src/benchmarking.rs
@@ -17,14 +17,13 @@
 
 //! Preimage pallet benchmarking.
 
-use super::*;
 use alloc::vec;
-use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller, BenchmarkError};
+use frame_benchmarking::v2::*;
 use frame_support::assert_ok;
 use frame_system::RawOrigin;
 use sp_runtime::traits::Bounded;
 
-use crate::Pallet as Preimage;
+use crate::*;
 
 fn funded_account<T: Config>() -> T::AccountId {
 	let caller: T::AccountId = whitelisted_caller();
@@ -43,206 +42,225 @@ fn sized_preimage_and_hash<T: Config>(size: u32) -> (Vec<u8>, T::Hash) {
 	(preimage, hash)
 }
 
-benchmarks! {
+fn insert_old_unrequested<T: Config>(s: u32) -> <T as frame_system::Config>::Hash {
+	let acc = account("old", s, 0);
+	T::Currency::make_free_balance_be(&acc, BalanceOf::<T>::max_value() / 2u32.into());
+
+	// The preimage size does not matter here as it is not touched.
+	let preimage = s.to_le_bytes();
+	let hash = <T as frame_system::Config>::Hashing::hash(&preimage[..]);
+
+	#[allow(deprecated)]
+	StatusFor::<T>::insert(
+		&hash,
+		OldRequestStatus::Unrequested { deposit: (acc, 123u32.into()), len: preimage.len() as u32 },
+	);
+	hash
+}
+
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
 	// Expensive note - will reserve.
-	note_preimage {
-		let s in 0 .. MAX_SIZE;
+	#[benchmark]
+	fn note_preimage(s: Linear<0, MAX_SIZE>) {
 		let caller = funded_account::<T>();
 		let (preimage, hash) = sized_preimage_and_hash::<T>(s);
-	}: _(RawOrigin::Signed(caller), preimage)
-	verify {
-		assert!(Preimage::<T>::have_preimage(&hash));
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), preimage);
+
+		assert!(Pallet::<T>::have_preimage(&hash));
 	}
+
 	// Cheap note - will not reserve since it was requested.
-	note_requested_preimage {
-		let s in 0 .. MAX_SIZE;
+	#[benchmark]
+	fn note_requested_preimage(s: Linear<0, MAX_SIZE>) {
 		let caller = funded_account::<T>();
 		let (preimage, hash) = sized_preimage_and_hash::<T>(s);
-		assert_ok!(Preimage::<T>::request_preimage(
+		assert_ok!(Pallet::<T>::request_preimage(
 			T::ManagerOrigin::try_successful_origin()
 				.expect("ManagerOrigin has no successful origin required for the benchmark"),
 			hash,
 		));
-	}: note_preimage(RawOrigin::Signed(caller), preimage)
-	verify {
-		assert!(Preimage::<T>::have_preimage(&hash));
+
+		#[extrinsic_call]
+		note_preimage(RawOrigin::Signed(caller), preimage);
+
+		assert!(Pallet::<T>::have_preimage(&hash));
 	}
+
 	// Cheap note - will not reserve since it's the manager.
-	note_no_deposit_preimage {
-		let s in 0 .. MAX_SIZE;
+	#[benchmark]
+	fn note_no_deposit_preimage(s: Linear<0, MAX_SIZE>) {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (preimage, hash) = sized_preimage_and_hash::<T>(s);
-		assert_ok!(Preimage::<T>::request_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			hash,
-		));
-	}: note_preimage<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		preimage
-	) verify {
-		assert!(Preimage::<T>::have_preimage(&hash));
+		assert_ok!(Pallet::<T>::request_preimage(o.clone(), hash,));
+
+		#[extrinsic_call]
+		note_preimage(o as T::RuntimeOrigin, preimage);
+
+		assert!(Pallet::<T>::have_preimage(&hash));
 	}
 
 	// Expensive unnote - will unreserve.
-	unnote_preimage {
+	#[benchmark]
+	fn unnote_preimage() {
 		let caller = funded_account::<T>();
 		let (preimage, hash) = preimage_and_hash::<T>();
-		assert_ok!(Preimage::<T>::note_preimage(RawOrigin::Signed(caller.clone()).into(), preimage));
-	}: _(RawOrigin::Signed(caller), hash)
-	verify {
-		assert!(!Preimage::<T>::have_preimage(&hash));
+		assert_ok!(Pallet::<T>::note_preimage(RawOrigin::Signed(caller.clone()).into(), preimage));
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), hash);
+
+		assert!(!Pallet::<T>::have_preimage(&hash));
 	}
+
 	// Cheap unnote - will not unreserve since there's no deposit held.
-	unnote_no_deposit_preimage {
+	#[benchmark]
+	fn unnote_no_deposit_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (preimage, hash) = preimage_and_hash::<T>();
-		assert_ok!(Preimage::<T>::note_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			preimage,
-		));
-	}: unnote_preimage<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
-		assert!(!Preimage::<T>::have_preimage(&hash));
+		assert_ok!(Pallet::<T>::note_preimage(o.clone(), preimage,));
+
+		#[extrinsic_call]
+		unnote_preimage(o as T::RuntimeOrigin, hash);
+
+		assert!(!Pallet::<T>::have_preimage(&hash));
 	}
 
 	// Expensive request - will unreserve the noter's deposit.
-	request_preimage {
+	#[benchmark]
+	fn request_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (preimage, hash) = preimage_and_hash::<T>();
 		let noter = funded_account::<T>();
-		assert_ok!(Preimage::<T>::note_preimage(RawOrigin::Signed(noter.clone()).into(), preimage));
-	}: _<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
-		let ticket = TicketOf::<T>::new(&noter, Footprint { count: 1, size: MAX_SIZE as u64 }).unwrap();
-		let s = RequestStatus::Requested { maybe_ticket: Some((noter, ticket)), count: 1, maybe_len: Some(MAX_SIZE) };
+		assert_ok!(Pallet::<T>::note_preimage(RawOrigin::Signed(noter.clone()).into(), preimage));
+
+		#[extrinsic_call]
+		_(o as T::RuntimeOrigin, hash);
+
+		let ticket =
+			TicketOf::<T>::new(&noter, Footprint { count: 1, size: MAX_SIZE as u64 }).unwrap();
+		let s = RequestStatus::Requested {
+			maybe_ticket: Some((noter, ticket)),
+			count: 1,
+			maybe_len: Some(MAX_SIZE),
+		};
 		assert_eq!(RequestStatusFor::<T>::get(&hash), Some(s));
 	}
+
 	// Cheap request - would unreserve the deposit but none was held.
-	request_no_deposit_preimage {
+	#[benchmark]
+	fn request_no_deposit_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (preimage, hash) = preimage_and_hash::<T>();
-		assert_ok!(Preimage::<T>::note_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			preimage,
-		));
-	}: request_preimage<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
-		let s = RequestStatus::Requested { maybe_ticket: None, count: 2, maybe_len: Some(MAX_SIZE) };
+		assert_ok!(Pallet::<T>::note_preimage(o.clone(), preimage,));
+
+		#[extrinsic_call]
+		request_preimage(o as T::RuntimeOrigin, hash);
+
+		let s =
+			RequestStatus::Requested { maybe_ticket: None, count: 2, maybe_len: Some(MAX_SIZE) };
 		assert_eq!(RequestStatusFor::<T>::get(&hash), Some(s));
 	}
+
 	// Cheap request - the preimage is not yet noted, so deposit to unreserve.
-	request_unnoted_preimage {
+	#[benchmark]
+	fn request_unnoted_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (_, hash) = preimage_and_hash::<T>();
-	}: request_preimage<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
+
+		#[extrinsic_call]
+		request_preimage(o as T::RuntimeOrigin, hash);
+
 		let s = RequestStatus::Requested { maybe_ticket: None, count: 1, maybe_len: None };
 		assert_eq!(RequestStatusFor::<T>::get(&hash), Some(s));
 	}
+
 	// Cheap request - the preimage is already requested, so just a counter bump.
-	request_requested_preimage {
+	#[benchmark]
+	fn request_requested_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (_, hash) = preimage_and_hash::<T>();
-		assert_ok!(Preimage::<T>::request_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			hash,
-		));
-	}: request_preimage<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
+		assert_ok!(Pallet::<T>::request_preimage(o.clone(), hash,));
+
+		#[extrinsic_call]
+		request_preimage(o as T::RuntimeOrigin, hash);
+
 		let s = RequestStatus::Requested { maybe_ticket: None, count: 2, maybe_len: None };
 		assert_eq!(RequestStatusFor::<T>::get(&hash), Some(s));
 	}
 
 	// Expensive unrequest - last reference and it's noted, so will destroy the preimage.
-	unrequest_preimage {
+	#[benchmark]
+	fn unrequest_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (preimage, hash) = preimage_and_hash::<T>();
-		assert_ok!(Preimage::<T>::request_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			hash,
-		));
-		assert_ok!(Preimage::<T>::note_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			preimage,
-		));
-	}: _<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
+		assert_ok!(Pallet::<T>::request_preimage(o.clone(), hash,));
+		assert_ok!(Pallet::<T>::note_preimage(o.clone(), preimage));
+
+		#[extrinsic_call]
+		_(o as T::RuntimeOrigin, hash);
+
 		assert_eq!(RequestStatusFor::<T>::get(&hash), None);
 	}
+
 	// Cheap unrequest - last reference, but it's not noted.
-	unrequest_unnoted_preimage {
+	#[benchmark]
+	fn unrequest_unnoted_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (_, hash) = preimage_and_hash::<T>();
-		assert_ok!(Preimage::<T>::request_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			hash,
-		));
-	}: unrequest_preimage<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
+		assert_ok!(Pallet::<T>::request_preimage(o.clone(), hash,));
+
+		#[extrinsic_call]
+		unrequest_preimage(o as T::RuntimeOrigin, hash);
+
 		assert_eq!(RequestStatusFor::<T>::get(&hash), None);
 	}
+
 	// Cheap unrequest - not the last reference.
-	unrequest_multi_referenced_preimage {
+	#[benchmark]
+	fn unrequest_multi_referenced_preimage() {
+		let o = T::ManagerOrigin::try_successful_origin()
+			.expect("ManagerOrigin has no successful origin required for the benchmark");
 		let (_, hash) = preimage_and_hash::<T>();
-		assert_ok!(Preimage::<T>::request_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			hash,
-		));
-		assert_ok!(Preimage::<T>::request_preimage(
-			T::ManagerOrigin::try_successful_origin()
-				.expect("ManagerOrigin has no successful origin required for the benchmark"),
-			hash,
-		));
-	}: unrequest_preimage<T::RuntimeOrigin>(
-		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
-		hash
-	) verify {
+		assert_ok!(Pallet::<T>::request_preimage(o.clone(), hash,));
+		assert_ok!(Pallet::<T>::request_preimage(o.clone(), hash,));
+
+		#[extrinsic_call]
+		unrequest_preimage(o as T::RuntimeOrigin, hash);
+
 		let s = RequestStatus::Requested { maybe_ticket: None, count: 1, maybe_len: None };
 		assert_eq!(RequestStatusFor::<T>::get(&hash), Some(s));
 	}
 
-	ensure_updated {
-		let n in 1..MAX_HASH_UPGRADE_BULK_COUNT;
-
+	#[benchmark]
+	fn ensure_updated(n: Linear<1, MAX_HASH_UPGRADE_BULK_COUNT>) {
 		let caller = funded_account::<T>();
 		let hashes = (0..n).map(|i| insert_old_unrequested::<T>(i)).collect::<Vec<_>>();
-	}: _(RawOrigin::Signed(caller), hashes)
-	verify {
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), hashes);
+
 		assert_eq!(RequestStatusFor::<T>::iter_keys().count(), n as usize);
 		#[allow(deprecated)]
 		let c = StatusFor::<T>::iter_keys().count();
 		assert_eq!(c, 0);
 	}
 
-	impl_benchmark_test_suite!(Preimage, crate::mock::new_test_ext(), crate::mock::Test);
-}
-
-fn insert_old_unrequested<T: Config>(s: u32) -> <T as frame_system::Config>::Hash {
-	let acc = account("old", s, 0);
-	T::Currency::make_free_balance_be(&acc, BalanceOf::<T>::max_value() / 2u32.into());
-
-	// The preimage size does not matter here as it is not touched.
-	let preimage = s.to_le_bytes();
-	let hash = <T as frame_system::Config>::Hashing::hash(&preimage[..]);
-
-	#[allow(deprecated)]
-	StatusFor::<T>::insert(
-		&hash,
-		OldRequestStatus::Unrequested { deposit: (acc, 123u32.into()), len: preimage.len() as u32 },
-	);
-	hash
+	impl_benchmark_test_suite! {
+		Pallet,
+		mock::new_test_ext(),
+		mock::Test
+	}
 }
diff --git a/substrate/frame/preimage/src/weights.rs b/substrate/frame/preimage/src/weights.rs
index edb2eed9c75a..a3aec7e7546e 100644
--- a/substrate/frame/preimage/src/weights.rs
+++ b/substrate/frame/preimage/src/weights.rs
@@ -18,27 +18,25 @@
 //! Autogenerated weights for `pallet_preimage`
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
-//! DATE: 2024-11-08, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2024-11-28, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
 //! HOSTNAME: `runner-wiukf8gn-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
 //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024`
 
 // Executed Command:
-// ./target/production/substrate-node
+// target/production/substrate-node
 // benchmark
 // pallet
-// --chain=dev
 // --steps=50
 // --repeat=20
-// --pallet=pallet_preimage
-// --no-storage-info
-// --no-median-slopes
-// --no-min-squares
 // --extrinsic=*
 // --wasm-execution=compiled
 // --heap-pages=4096
-// --output=./substrate/frame/preimage/src/weights.rs
+// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json
+// --pallet=pallet_preimage
+// --chain=dev
 // --header=./substrate/HEADER-APACHE2
+// --output=./substrate/frame/preimage/src/weights.rs
 // --template=./substrate/.maintain/frame-weight-template.hbs
 
 #![cfg_attr(rustfmt, rustfmt_skip)]
@@ -84,10 +82,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `7`
 		//  Estimated: `6012`
-		// Minimum execution time: 51_981_000 picoseconds.
-		Weight::from_parts(52_228_000, 6012)
-			// Standard Error: 6
-			.saturating_add(Weight::from_parts(2_392, 0).saturating_mul(s.into()))
+		// Minimum execution time: 51_305_000 picoseconds.
+		Weight::from_parts(51_670_000, 6012)
+			// Standard Error: 5
+			.saturating_add(Weight::from_parts(2_337, 0).saturating_mul(s.into()))
 			.saturating_add(T::DbWeight::get().reads(5_u64))
 			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
@@ -102,10 +100,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `68`
 		//  Estimated: `3556`
-		// Minimum execution time: 15_835_000 picoseconds.
-		Weight::from_parts(16_429_000, 3556)
-			// Standard Error: 8
-			.saturating_add(Weight::from_parts(2_647, 0).saturating_mul(s.into()))
+		// Minimum execution time: 16_204_000 picoseconds.
+		Weight::from_parts(16_613_000, 3556)
+			// Standard Error: 6
+			.saturating_add(Weight::from_parts(2_503, 0).saturating_mul(s.into()))
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -120,10 +118,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `68`
 		//  Estimated: `3556`
-		// Minimum execution time: 15_263_000 picoseconds.
-		Weight::from_parts(15_578_000, 3556)
-			// Standard Error: 7
-			.saturating_add(Weight::from_parts(2_598, 0).saturating_mul(s.into()))
+		// Minimum execution time: 15_118_000 picoseconds.
+		Weight::from_parts(15_412_000, 3556)
+			// Standard Error: 6
+			.saturating_add(Weight::from_parts(2_411, 0).saturating_mul(s.into()))
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -139,8 +137,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `206`
 		//  Estimated: `3820`
-		// Minimum execution time: 64_189_000 picoseconds.
-		Weight::from_parts(70_371_000, 3820)
+		// Minimum execution time: 57_218_000 picoseconds.
+		Weight::from_parts(61_242_000, 3820)
 			.saturating_add(T::DbWeight::get().reads(3_u64))
 			.saturating_add(T::DbWeight::get().writes(3_u64))
 	}
@@ -154,8 +152,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 27_582_000 picoseconds.
-		Weight::from_parts(31_256_000, 3556)
+		// Minimum execution time: 25_140_000 picoseconds.
+		Weight::from_parts(27_682_000, 3556)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -167,8 +165,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `150`
 		//  Estimated: `3556`
-		// Minimum execution time: 27_667_000 picoseconds.
-		Weight::from_parts(32_088_000, 3556)
+		// Minimum execution time: 25_296_000 picoseconds.
+		Weight::from_parts(27_413_000, 3556)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -180,8 +178,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 16_065_000 picoseconds.
-		Weight::from_parts(20_550_000, 3556)
+		// Minimum execution time: 15_011_000 picoseconds.
+		Weight::from_parts(16_524_000, 3556)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -193,8 +191,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `4`
 		//  Estimated: `3556`
-		// Minimum execution time: 13_638_000 picoseconds.
-		Weight::from_parts(16_979_000, 3556)
+		// Minimum execution time: 14_649_000 picoseconds.
+		Weight::from_parts(15_439_000, 3556)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -206,8 +204,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `68`
 		//  Estimated: `3556`
-		// Minimum execution time: 11_383_000 picoseconds.
-		Weight::from_parts(12_154_000, 3556)
+		// Minimum execution time: 10_914_000 picoseconds.
+		Weight::from_parts(11_137_000, 3556)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -221,8 +219,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 22_832_000 picoseconds.
-		Weight::from_parts(30_716_000, 3556)
+		// Minimum execution time: 22_512_000 picoseconds.
+		Weight::from_parts(24_376_000, 3556)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
@@ -234,8 +232,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `68`
 		//  Estimated: `3556`
-		// Minimum execution time: 10_685_000 picoseconds.
-		Weight::from_parts(12_129_000, 3556)
+		// Minimum execution time: 10_571_000 picoseconds.
+		Weight::from_parts(10_855_000, 3556)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -247,8 +245,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `68`
 		//  Estimated: `3556`
-		// Minimum execution time: 10_394_000 picoseconds.
-		Weight::from_parts(10_951_000, 3556)
+		// Minimum execution time: 10_312_000 picoseconds.
+		Weight::from_parts(10_653_000, 3556)
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
@@ -267,10 +265,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 		// Proof Size summary in bytes:
 		//  Measured:  `0 + n * (227 ±0)`
 		//  Estimated: `6012 + n * (2830 ±0)`
-		// Minimum execution time: 62_203_000 picoseconds.
-		Weight::from_parts(63_735_000, 6012)
-			// Standard Error: 59_589
-			.saturating_add(Weight::from_parts(59_482_352, 0).saturating_mul(n.into()))
+		// Minimum execution time: 61_990_000 picoseconds.
+		Weight::from_parts(62_751_000, 6012)
+			// Standard Error: 44_079
+			.saturating_add(Weight::from_parts(57_343_378, 0).saturating_mul(n.into()))
 			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(n.into())))
 			.saturating_add(T::DbWeight::get().writes((4_u64).saturating_mul(n.into())))
@@ -295,10 +293,10 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `7`
 		//  Estimated: `6012`
-		// Minimum execution time: 51_981_000 picoseconds.
-		Weight::from_parts(52_228_000, 6012)
-			// Standard Error: 6
-			.saturating_add(Weight::from_parts(2_392, 0).saturating_mul(s.into()))
+		// Minimum execution time: 51_305_000 picoseconds.
+		Weight::from_parts(51_670_000, 6012)
+			// Standard Error: 5
+			.saturating_add(Weight::from_parts(2_337, 0).saturating_mul(s.into()))
 			.saturating_add(RocksDbWeight::get().reads(5_u64))
 			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
@@ -313,10 +311,10 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `68`
 		//  Estimated: `3556`
-		// Minimum execution time: 15_835_000 picoseconds.
-		Weight::from_parts(16_429_000, 3556)
-			// Standard Error: 8
-			.saturating_add(Weight::from_parts(2_647, 0).saturating_mul(s.into()))
+		// Minimum execution time: 16_204_000 picoseconds.
+		Weight::from_parts(16_613_000, 3556)
+			// Standard Error: 6
+			.saturating_add(Weight::from_parts(2_503, 0).saturating_mul(s.into()))
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -331,10 +329,10 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `68`
 		//  Estimated: `3556`
-		// Minimum execution time: 15_263_000 picoseconds.
-		Weight::from_parts(15_578_000, 3556)
-			// Standard Error: 7
-			.saturating_add(Weight::from_parts(2_598, 0).saturating_mul(s.into()))
+		// Minimum execution time: 15_118_000 picoseconds.
+		Weight::from_parts(15_412_000, 3556)
+			// Standard Error: 6
+			.saturating_add(Weight::from_parts(2_411, 0).saturating_mul(s.into()))
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -350,8 +348,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `206`
 		//  Estimated: `3820`
-		// Minimum execution time: 64_189_000 picoseconds.
-		Weight::from_parts(70_371_000, 3820)
+		// Minimum execution time: 57_218_000 picoseconds.
+		Weight::from_parts(61_242_000, 3820)
 			.saturating_add(RocksDbWeight::get().reads(3_u64))
 			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
@@ -365,8 +363,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 27_582_000 picoseconds.
-		Weight::from_parts(31_256_000, 3556)
+		// Minimum execution time: 25_140_000 picoseconds.
+		Weight::from_parts(27_682_000, 3556)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -378,8 +376,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `150`
 		//  Estimated: `3556`
-		// Minimum execution time: 27_667_000 picoseconds.
-		Weight::from_parts(32_088_000, 3556)
+		// Minimum execution time: 25_296_000 picoseconds.
+		Weight::from_parts(27_413_000, 3556)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -391,8 +389,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 16_065_000 picoseconds.
-		Weight::from_parts(20_550_000, 3556)
+		// Minimum execution time: 15_011_000 picoseconds.
+		Weight::from_parts(16_524_000, 3556)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -404,8 +402,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `4`
 		//  Estimated: `3556`
-		// Minimum execution time: 13_638_000 picoseconds.
-		Weight::from_parts(16_979_000, 3556)
+		// Minimum execution time: 14_649_000 picoseconds.
+		Weight::from_parts(15_439_000, 3556)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -417,8 +415,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `68`
 		//  Estimated: `3556`
-		// Minimum execution time: 11_383_000 picoseconds.
-		Weight::from_parts(12_154_000, 3556)
+		// Minimum execution time: 10_914_000 picoseconds.
+		Weight::from_parts(11_137_000, 3556)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -432,8 +430,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 22_832_000 picoseconds.
-		Weight::from_parts(30_716_000, 3556)
+		// Minimum execution time: 22_512_000 picoseconds.
+		Weight::from_parts(24_376_000, 3556)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
@@ -445,8 +443,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `68`
 		//  Estimated: `3556`
-		// Minimum execution time: 10_685_000 picoseconds.
-		Weight::from_parts(12_129_000, 3556)
+		// Minimum execution time: 10_571_000 picoseconds.
+		Weight::from_parts(10_855_000, 3556)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -458,8 +456,8 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `68`
 		//  Estimated: `3556`
-		// Minimum execution time: 10_394_000 picoseconds.
-		Weight::from_parts(10_951_000, 3556)
+		// Minimum execution time: 10_312_000 picoseconds.
+		Weight::from_parts(10_653_000, 3556)
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
@@ -478,10 +476,10 @@ impl WeightInfo for () {
 		// Proof Size summary in bytes:
 		//  Measured:  `0 + n * (227 ±0)`
 		//  Estimated: `6012 + n * (2830 ±0)`
-		// Minimum execution time: 62_203_000 picoseconds.
-		Weight::from_parts(63_735_000, 6012)
-			// Standard Error: 59_589
-			.saturating_add(Weight::from_parts(59_482_352, 0).saturating_mul(n.into()))
+		// Minimum execution time: 61_990_000 picoseconds.
+		Weight::from_parts(62_751_000, 6012)
+			// Standard Error: 44_079
+			.saturating_add(Weight::from_parts(57_343_378, 0).saturating_mul(n.into()))
 			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(n.into())))
 			.saturating_add(RocksDbWeight::get().writes((4_u64).saturating_mul(n.into())))

From 447902eff4a574e66894ad60cb41999b05bf5e84 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= <alex.theissen@me.com>
Date: Fri, 29 Nov 2024 13:46:31 +0100
Subject: [PATCH 2/5] pallet_revive: Switch to 64bit RISC-V (#6565)

This PR updates pallet_revive to the newest PolkaVM version and adapts
the test fixtures and syscall interface to work under 64bit.

Please note that after this PR no 32bit contracts can be deployed (they
will be rejected at deploy time). Pre-deployed 32bit contracts are now
considered defunct since we changes how parameters are passed for
functions with more than 6 arguments.

## Fixtures

The fixtures are now built for the 64bit target. I also removed the
temporary directory mechanism that triggered a full rebuild every time.
It also makes it easier to find the compiled fixtures since they are now
always in `target/pallet-revive-fixtures`.

## Syscall interface

### Passing pointer

Registers and pointers are now 64bit wide. This allows us to pass u64
arguments in a single register. Before we needed two registers to pass
them. This means that just as before we need one register per pointer we
pass. We keep pointers as `u32` argument by truncating the register.
This is done since the memory space of PolkaVM is 32bit.

### Functions with more than 6 arguments

We only have 6 registers to pass arguments. This is why we pass a
pointer to a struct when we need more than 6. Before this PR we expected
a packed struct and interpreted it as SCALE encoded tuple. However, this
was buggy because the `MaxEncodedLen` returned something that was larger
than the packed size of the structure. This wasn't a problem before. But
now the memory space changed in a way that things were placed at the
edges of the memory space and those extra bytes lead to an out of bound
access.

This is why this PR drops SCALE and expects the arguments to be passed
as a pointer to a `C` aligned struct. This avoids unaligned accesses.
However, revive needs to adapt its codegen to properly align the
structure fields.

## TODO
- [ ] Add multi block migration that wipes all existing contracts as we
made breaking changes to the syscall interface

---------

Co-authored-by: GitHub Action <action@github.com>
---
 .github/workflows/checks-quick.yml            |  1 -
 Cargo.lock                                    | 72 +++++++-------
 prdoc/pr_6565.prdoc                           | 35 +++++++
 substrate/frame/revive/Cargo.toml             |  2 +-
 substrate/frame/revive/fixtures/Cargo.toml    |  4 +-
 substrate/frame/revive/fixtures/build.rs      | 96 +++++++++++++------
 .../build/{Cargo.toml => _Cargo.toml}         |  5 +-
 .../fixtures/build/_rust-toolchain.toml       |  4 +
 .../riscv32emac-unknown-none-polkavm.json     | 26 -----
 substrate/frame/revive/fixtures/src/lib.rs    | 13 +--
 substrate/frame/revive/proc-macro/src/lib.rs  | 91 ++++++++++--------
 substrate/frame/revive/rpc/src/tests.rs       |  6 ++
 substrate/frame/revive/src/chain_extension.rs | 12 +--
 substrate/frame/revive/src/limits.rs          | 21 +++-
 substrate/frame/revive/src/wasm/mod.rs        | 20 +++-
 substrate/frame/revive/src/wasm/runtime.rs    | 33 ++-----
 substrate/frame/revive/uapi/Cargo.toml        |  6 +-
 substrate/frame/revive/uapi/src/host.rs       |  4 +-
 .../uapi/src/host/{riscv32.rs => riscv64.rs}  | 86 ++++++++---------
 substrate/frame/revive/uapi/src/lib.rs        |  6 ++
 20 files changed, 309 insertions(+), 234 deletions(-)
 create mode 100644 prdoc/pr_6565.prdoc
 rename substrate/frame/revive/fixtures/build/{Cargo.toml => _Cargo.toml} (80%)
 create mode 100644 substrate/frame/revive/fixtures/build/_rust-toolchain.toml
 delete mode 100644 substrate/frame/revive/fixtures/riscv32emac-unknown-none-polkavm.json
 rename substrate/frame/revive/uapi/src/host/{riscv32.rs => riscv64.rs} (93%)

diff --git a/.github/workflows/checks-quick.yml b/.github/workflows/checks-quick.yml
index c733a2517cb8..4c26b85a6303 100644
--- a/.github/workflows/checks-quick.yml
+++ b/.github/workflows/checks-quick.yml
@@ -97,7 +97,6 @@ jobs:
           --exclude
           "substrate/frame/contracts/fixtures/build"
           "substrate/frame/contracts/fixtures/contracts/common"
-          "substrate/frame/revive/fixtures/build"
           "substrate/frame/revive/fixtures/contracts/common"
       - name: deny git deps
         run: python3 .github/scripts/deny-git-deps.py .
diff --git a/Cargo.lock b/Cargo.lock
index 84477cd05416..e1abeea49283 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5975,6 +5975,15 @@ dependencies = [
  "dirs-sys-next",
 ]
 
+[[package]]
+name = "dirs"
+version = "5.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
+dependencies = [
+ "dirs-sys",
+]
+
 [[package]]
 name = "dirs-sys"
 version = "0.4.1"
@@ -14646,7 +14655,7 @@ dependencies = [
  "pallet-utility 28.0.0",
  "parity-scale-codec",
  "paste",
- "polkavm 0.13.0",
+ "polkavm 0.17.0",
  "pretty_assertions",
  "rlp 0.6.1",
  "scale-info",
@@ -14742,12 +14751,10 @@ dependencies = [
  "anyhow",
  "frame-system 28.0.0",
  "log",
- "parity-wasm",
- "polkavm-linker 0.14.0",
+ "polkavm-linker 0.17.0",
  "sp-core 28.0.0",
  "sp-io 30.0.0",
  "sp-runtime 31.0.1",
- "tempfile",
  "toml 0.8.12",
 ]
 
@@ -14864,7 +14871,7 @@ dependencies = [
  "bitflags 1.3.2",
  "parity-scale-codec",
  "paste",
- "polkavm-derive 0.14.0",
+ "polkavm-derive 0.17.0",
  "scale-info",
 ]
 
@@ -19699,15 +19706,15 @@ dependencies = [
 
 [[package]]
 name = "polkavm"
-version = "0.13.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57e79a14b15ed38cb5b9a1e38d02e933f19e3d180ae5b325fed606c5e5b9177e"
+checksum = "84979be196ba2855f73616413e7b1d18258128aa396b3dc23f520a00a807720e"
 dependencies = [
  "libc",
  "log",
- "polkavm-assembler 0.13.0",
- "polkavm-common 0.13.0",
- "polkavm-linux-raw 0.13.0",
+ "polkavm-assembler 0.17.0",
+ "polkavm-common 0.17.0",
+ "polkavm-linux-raw 0.17.0",
 ]
 
 [[package]]
@@ -19730,9 +19737,9 @@ dependencies = [
 
 [[package]]
 name = "polkavm-assembler"
-version = "0.13.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e8da55465000feb0a61bbf556ed03024db58f3420eca37721fc726b3b2136bf"
+checksum = "0ba7b434ff630b0f73a1560e8baea807246ca22098abe49f97821e0e2d2accc4"
 dependencies = [
  "log",
 ]
@@ -19764,20 +19771,14 @@ dependencies = [
 
 [[package]]
 name = "polkavm-common"
-version = "0.13.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "084b4339aae7dfdaaa5aa7d634110afd95970e0737b6fb2a0cb10db8b56b753c"
+checksum = "8f0dbafef4ab6ceecb4982ac3b550df430ef4f9fdbf07c108b7d4f91a0682fce"
 dependencies = [
  "log",
- "polkavm-assembler 0.13.0",
+ "polkavm-assembler 0.17.0",
 ]
 
-[[package]]
-name = "polkavm-common"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "711952a783e9c5ad407cdacb1ed147f36d37c5d43417c1091d86456d2999417b"
-
 [[package]]
 name = "polkavm-derive"
 version = "0.8.0"
@@ -19807,11 +19808,11 @@ dependencies = [
 
 [[package]]
 name = "polkavm-derive"
-version = "0.14.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4832a0aebf6cefc988bb7b2d74ea8c86c983164672e2fc96300f356a1babfc1"
+checksum = "c0c3dbb6c8c7bd3e5f5b05aa7fc9355acf14df7ce5d392911e77d01090a38d0d"
 dependencies = [
- "polkavm-derive-impl-macro 0.14.0",
+ "polkavm-derive-impl-macro 0.17.0",
 ]
 
 [[package]]
@@ -19852,11 +19853,11 @@ dependencies = [
 
 [[package]]
 name = "polkavm-derive-impl"
-version = "0.14.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e339fc7c11310fe5adf711d9342278ac44a75c9784947937cce12bd4f30842f2"
+checksum = "42565aed4adbc4034612d0b17dea8db3681fb1bd1aed040d6edc5455a9f478a1"
 dependencies = [
- "polkavm-common 0.14.0",
+ "polkavm-common 0.17.0",
  "proc-macro2 1.0.86",
  "quote 1.0.37",
  "syn 2.0.87",
@@ -19894,11 +19895,11 @@ dependencies = [
 
 [[package]]
 name = "polkavm-derive-impl-macro"
-version = "0.14.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b569754b15060d03000c09e3bf11509d527f60b75d79b4c30c3625b5071d9702"
+checksum = "86d9838e95241b0bce4fe269cdd4af96464160505840ed5a8ac8536119ba19e2"
 dependencies = [
- "polkavm-derive-impl 0.14.0",
+ "polkavm-derive-impl 0.17.0",
  "syn 2.0.87",
 ]
 
@@ -19934,15 +19935,16 @@ dependencies = [
 
 [[package]]
 name = "polkavm-linker"
-version = "0.14.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0959ac3b0f4fd5caf5c245c637705f19493efe83dba31a83bbba928b93b0116a"
+checksum = "d359dc721d2cc9b555ebb3558c305112ddc5bdac09d26f95f2f7b49c1f2db7e9"
 dependencies = [
+ "dirs",
  "gimli 0.31.1",
  "hashbrown 0.14.5",
  "log",
  "object 0.36.1",
- "polkavm-common 0.14.0",
+ "polkavm-common 0.17.0",
  "regalloc2 0.9.3",
  "rustc-demangle",
 ]
@@ -19961,9 +19963,9 @@ checksum = "26e45fa59c7e1bb12ef5289080601e9ec9b31435f6e32800a5c90c132453d126"
 
 [[package]]
 name = "polkavm-linux-raw"
-version = "0.13.0"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "686c4dd9c9c16cc22565b51bdbb269792318d0fd2e6b966b5f6c788534cad0e9"
+checksum = "e64c3d93a58ffbc3099d1227f0da9675a025a9ea6c917038f266920c1de1e568"
 
 [[package]]
 name = "polling"
diff --git a/prdoc/pr_6565.prdoc b/prdoc/pr_6565.prdoc
new file mode 100644
index 000000000000..f9a75a16a6a7
--- /dev/null
+++ b/prdoc/pr_6565.prdoc
@@ -0,0 +1,35 @@
+title: 'pallet_revive: Switch to 64bit RISC-V'
+doc:
+- audience: Runtime Dev
+  description: |-
+    This PR updates pallet_revive to the newest PolkaVM version and adapts the test fixtures and syscall interface to work under 64bit.
+
+    Please note that after this PR no 32bit contracts can be deployed (they will be rejected at deploy time). Pre-deployed 32bit contracts are now considered defunct since we changes how parameters are passed for functions with more than 6 arguments.
+
+    ## Fixtures
+
+    The fixtures are now built for the 64bit target. I also removed the temporary directory mechanism that triggered a full rebuild every time. It also makes it easier to find the compiled fixtures since they are now always in `target/pallet-revive-fixtures`.
+
+    ## Syscall interface
+
+    ### Passing pointer
+
+    Registers and pointers are now 64bit wide. This allows us to pass u64 arguments in a single register. Before we needed two registers to pass them. This means that just as before we need one register per pointer we pass. We keep pointers as `u32` argument by truncating the register. This is done since the memory space of PolkaVM is 32bit.
+
+    ### Functions with more than 6 arguments
+
+    We only have 6 registers to pass arguments. This is why we pass a pointer to a struct when we need more than 6. Before this PR we expected a packed struct and interpreted it as SCALE encoded tuple. However, this was buggy because the `MaxEncodedLen` returned something that was larger than the packed size of the structure. This wasn't a problem before. But now the memory space changed in a way that things were placed at the edges of the memory space and those extra bytes lead to an out of bound access.
+
+    This is why this PR drops SCALE and expects the arguments to be passed as a pointer to a `C` aligned struct. This avoids unaligned accesses. However, revive needs to adapt its codegen to properly align the structure fields.
+
+    ## TODO
+    - [ ] Add multi block migration that wipes all existing contracts as we made breaking changes to the syscall interface
+crates:
+- name: pallet-revive
+  bump: major
+- name: pallet-revive-fixtures
+  bump: major
+- name: pallet-revive-proc-macro
+  bump: major
+- name: pallet-revive-uapi
+  bump: major
diff --git a/substrate/frame/revive/Cargo.toml b/substrate/frame/revive/Cargo.toml
index 81fbbc8cf38e..677ef0e1367f 100644
--- a/substrate/frame/revive/Cargo.toml
+++ b/substrate/frame/revive/Cargo.toml
@@ -19,7 +19,7 @@ targets = ["x86_64-unknown-linux-gnu"]
 [dependencies]
 environmental = { workspace = true }
 paste = { workspace = true }
-polkavm = { version = "0.13.0", default-features = false }
+polkavm = { version = "0.17.0", default-features = false }
 bitflags = { workspace = true }
 codec = { features = ["derive", "max-encoded-len"], workspace = true }
 scale-info = { features = ["derive"], workspace = true }
diff --git a/substrate/frame/revive/fixtures/Cargo.toml b/substrate/frame/revive/fixtures/Cargo.toml
index 7a5452853d65..798ed8c75a5a 100644
--- a/substrate/frame/revive/fixtures/Cargo.toml
+++ b/substrate/frame/revive/fixtures/Cargo.toml
@@ -18,10 +18,8 @@ anyhow = { workspace = true, default-features = true, optional = true }
 log = { workspace = true }
 
 [build-dependencies]
-parity-wasm = { workspace = true }
-tempfile = { workspace = true }
 toml = { workspace = true }
-polkavm-linker = { version = "0.14.0" }
+polkavm-linker = { version = "0.17.0" }
 anyhow = { workspace = true, default-features = true }
 
 [features]
diff --git a/substrate/frame/revive/fixtures/build.rs b/substrate/frame/revive/fixtures/build.rs
index 3472e0846efd..46cd5760ca4e 100644
--- a/substrate/frame/revive/fixtures/build.rs
+++ b/substrate/frame/revive/fixtures/build.rs
@@ -20,7 +20,8 @@ use anyhow::Result;
 
 use anyhow::{bail, Context};
 use std::{
-	cfg, env, fs,
+	env, fs,
+	io::Write,
 	path::{Path, PathBuf},
 	process::Command,
 };
@@ -82,7 +83,7 @@ fn create_cargo_toml<'a>(
 	entries: impl Iterator<Item = &'a Entry>,
 	output_dir: &Path,
 ) -> Result<()> {
-	let mut cargo_toml: toml::Value = toml::from_str(include_str!("./build/Cargo.toml"))?;
+	let mut cargo_toml: toml::Value = toml::from_str(include_str!("./build/_Cargo.toml"))?;
 	let mut set_dep = |name, path| -> Result<()> {
 		cargo_toml["dependencies"][name]["path"] = toml::Value::String(
 			fixtures_dir.join(path).canonicalize()?.to_str().unwrap().to_string(),
@@ -108,21 +109,24 @@ fn create_cargo_toml<'a>(
 	let cargo_toml = toml::to_string_pretty(&cargo_toml)?;
 	fs::write(output_dir.join("Cargo.toml"), cargo_toml.clone())
 		.with_context(|| format!("Failed to write {cargo_toml:?}"))?;
+	fs::copy(
+		fixtures_dir.join("build/_rust-toolchain.toml"),
+		output_dir.join("rust-toolchain.toml"),
+	)
+	.context("Failed to write toolchain file")?;
 	Ok(())
 }
 
-fn invoke_build(target: &Path, current_dir: &Path) -> Result<()> {
+fn invoke_build(current_dir: &Path) -> Result<()> {
 	let encoded_rustflags = ["-Dwarnings"].join("\x1f");
 
-	let mut build_command = Command::new(env::var("CARGO")?);
+	let mut build_command = Command::new("cargo");
 	build_command
 		.current_dir(current_dir)
 		.env_clear()
 		.env("PATH", env::var("PATH").unwrap_or_default())
 		.env("CARGO_ENCODED_RUSTFLAGS", encoded_rustflags)
-		.env("RUSTC_BOOTSTRAP", "1")
 		.env("RUSTUP_HOME", env::var("RUSTUP_HOME").unwrap_or_default())
-		.env("RUSTUP_TOOLCHAIN", env::var("RUSTUP_TOOLCHAIN").unwrap_or_default())
 		.args([
 			"build",
 			"--release",
@@ -130,7 +134,7 @@ fn invoke_build(target: &Path, current_dir: &Path) -> Result<()> {
 			"-Zbuild-std-features=panic_immediate_abort",
 		])
 		.arg("--target")
-		.arg(target);
+		.arg(polkavm_linker::target_json_64_path().unwrap());
 
 	if let Ok(toolchain) = env::var(OVERRIDE_RUSTUP_TOOLCHAIN_ENV_VAR) {
 		build_command.env("RUSTUP_TOOLCHAIN", &toolchain);
@@ -168,7 +172,7 @@ fn write_output(build_dir: &Path, out_dir: &Path, entries: Vec<Entry>) -> Result
 	for entry in entries {
 		post_process(
 			&build_dir
-				.join("target/riscv32emac-unknown-none-polkavm/release")
+				.join("target/riscv64emac-unknown-none-polkavm/release")
 				.join(entry.name()),
 			&out_dir.join(entry.out_filename()),
 		)?;
@@ -177,11 +181,61 @@ fn write_output(build_dir: &Path, out_dir: &Path, entries: Vec<Entry>) -> Result
 	Ok(())
 }
 
+/// Create a directory in the `target` as output directory
+fn create_out_dir() -> Result<PathBuf> {
+	let temp_dir: PathBuf = env::var("OUT_DIR")?.into();
+
+	// this is set in case the user has overriden the target directory
+	let out_dir = if let Ok(path) = env::var("CARGO_TARGET_DIR") {
+		path.into()
+	} else {
+		// otherwise just traverse up from the out dir
+		let mut out_dir: PathBuf = temp_dir.clone();
+		loop {
+			if !out_dir.pop() {
+				bail!("Cannot find project root.")
+			}
+			if out_dir.join("Cargo.lock").exists() {
+				break;
+			}
+		}
+		out_dir.join("target")
+	}
+	.join("pallet-revive-fixtures");
+
+	// clean up some leftover symlink from previous versions of this script
+	if out_dir.exists() && !out_dir.is_dir() {
+		fs::remove_file(&out_dir)?;
+	}
+	fs::create_dir_all(&out_dir).context("Failed to create output directory")?;
+
+	// write the location of the out dir so it can be found later
+	let mut file = fs::File::create(temp_dir.join("fixture_location.rs"))
+		.context("Failed to create fixture_location.rs")?;
+	write!(
+		file,
+		r#"
+			#[allow(dead_code)]
+			const FIXTURE_DIR: &str = "{0}";
+			macro_rules! fixture {{
+				($name: literal) => {{
+					include_bytes!(concat!("{0}", "/", $name, ".polkavm"))
+				}};
+			}}
+		"#,
+		out_dir.display()
+	)
+	.context("Failed to write to fixture_location.rs")?;
+
+	Ok(out_dir)
+}
+
 pub fn main() -> Result<()> {
 	let fixtures_dir: PathBuf = env::var("CARGO_MANIFEST_DIR")?.into();
 	let contracts_dir = fixtures_dir.join("contracts");
-	let out_dir: PathBuf = env::var("OUT_DIR")?.into();
-	let target = fixtures_dir.join("riscv32emac-unknown-none-polkavm.json");
+	let out_dir = create_out_dir().context("Cannot determine output directory")?;
+	let build_dir = out_dir.join("build");
+	fs::create_dir_all(&build_dir).context("Failed to create build directory")?;
 
 	println!("cargo::rerun-if-env-changed={OVERRIDE_RUSTUP_TOOLCHAIN_ENV_VAR}");
 	println!("cargo::rerun-if-env-changed={OVERRIDE_STRIP_ENV_VAR}");
@@ -199,25 +253,9 @@ pub fn main() -> Result<()> {
 		return Ok(())
 	}
 
-	let tmp_dir = tempfile::tempdir()?;
-	let tmp_dir_path = tmp_dir.path();
-
-	create_cargo_toml(&fixtures_dir, entries.iter(), tmp_dir.path())?;
-	invoke_build(&target, tmp_dir_path)?;
-
-	write_output(tmp_dir_path, &out_dir, entries)?;
-
-	#[cfg(unix)]
-	if let Ok(symlink_dir) = env::var("CARGO_WORKSPACE_ROOT_DIR") {
-		let symlink_dir: PathBuf = symlink_dir.into();
-		let symlink_dir: PathBuf = symlink_dir.join("target").join("pallet-revive-fixtures");
-		if symlink_dir.is_symlink() {
-			fs::remove_file(&symlink_dir)
-				.with_context(|| format!("Failed to remove_file {symlink_dir:?}"))?;
-		}
-		std::os::unix::fs::symlink(&out_dir, &symlink_dir)
-			.with_context(|| format!("Failed to symlink {out_dir:?} -> {symlink_dir:?}"))?;
-	}
+	create_cargo_toml(&fixtures_dir, entries.iter(), &build_dir)?;
+	invoke_build(&build_dir)?;
+	write_output(&build_dir, &out_dir, entries)?;
 
 	Ok(())
 }
diff --git a/substrate/frame/revive/fixtures/build/Cargo.toml b/substrate/frame/revive/fixtures/build/_Cargo.toml
similarity index 80%
rename from substrate/frame/revive/fixtures/build/Cargo.toml
rename to substrate/frame/revive/fixtures/build/_Cargo.toml
index 5d0e256e2e73..beaabd83403e 100644
--- a/substrate/frame/revive/fixtures/build/Cargo.toml
+++ b/substrate/frame/revive/fixtures/build/_Cargo.toml
@@ -4,6 +4,9 @@ publish = false
 version = "1.0.0"
 edition = "2021"
 
+# Make sure this is not included into the workspace
+[workspace]
+
 # Binary targets are injected dynamically by the build script.
 [[bin]]
 
@@ -11,7 +14,7 @@ edition = "2021"
 [dependencies]
 uapi = { package = 'pallet-revive-uapi', path = "", default-features = false }
 common = { package = 'pallet-revive-fixtures-common', path = "" }
-polkavm-derive = { version = "0.14.0" }
+polkavm-derive = { version = "0.17.0" }
 
 [profile.release]
 opt-level = 3
diff --git a/substrate/frame/revive/fixtures/build/_rust-toolchain.toml b/substrate/frame/revive/fixtures/build/_rust-toolchain.toml
new file mode 100644
index 000000000000..4c757c708d58
--- /dev/null
+++ b/substrate/frame/revive/fixtures/build/_rust-toolchain.toml
@@ -0,0 +1,4 @@
+[toolchain]
+channel = "nightly-2024-11-19"
+components = ["rust-src"]
+profile = "minimal"
diff --git a/substrate/frame/revive/fixtures/riscv32emac-unknown-none-polkavm.json b/substrate/frame/revive/fixtures/riscv32emac-unknown-none-polkavm.json
deleted file mode 100644
index bbd54cdefbac..000000000000
--- a/substrate/frame/revive/fixtures/riscv32emac-unknown-none-polkavm.json
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-  "arch": "riscv32",
-  "cpu": "generic-rv32",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-m:e-p:32:32-i64:64-n32-S32",
-  "eh-frame-header": false,
-  "emit-debug-gdb-scripts": false,
-  "features": "+e,+m,+a,+c,+lui-addi-fusion,+fast-unaligned-access,+xtheadcondmov",
-  "linker": "rust-lld",
-  "linker-flavor": "ld.lld",
-  "llvm-abiname": "ilp32e",
-  "llvm-target": "riscv32",
-  "max-atomic-width": 32,
-  "panic-strategy": "abort",
-  "relocation-model": "pie",
-  "target-pointer-width": "32",
-  "singlethread": true,
-  "pre-link-args": {
-    "ld": [
-      "--emit-relocs",
-      "--unique",
-      "--relocatable"
-    ]
-  },
-  "env": "polkavm"
-}
diff --git a/substrate/frame/revive/fixtures/src/lib.rs b/substrate/frame/revive/fixtures/src/lib.rs
index cc84daec9b59..24f6ee547dc7 100644
--- a/substrate/frame/revive/fixtures/src/lib.rs
+++ b/substrate/frame/revive/fixtures/src/lib.rs
@@ -19,10 +19,13 @@
 
 extern crate alloc;
 
+// generated file that tells us where to find the fixtures
+include!(concat!(env!("OUT_DIR"), "/fixture_location.rs"));
+
 /// Load a given wasm module and returns a wasm binary contents along with it's hash.
 #[cfg(feature = "std")]
 pub fn compile_module(fixture_name: &str) -> anyhow::Result<(Vec<u8>, sp_core::H256)> {
-	let out_dir: std::path::PathBuf = env!("OUT_DIR").into();
+	let out_dir: std::path::PathBuf = FIXTURE_DIR.into();
 	let fixture_path = out_dir.join(format!("{fixture_name}.polkavm"));
 	log::debug!("Loading fixture from {fixture_path:?}");
 	let binary = std::fs::read(fixture_path)?;
@@ -36,12 +39,6 @@ pub fn compile_module(fixture_name: &str) -> anyhow::Result<(Vec<u8>, sp_core::H
 /// available in no-std environments (runtime benchmarks).
 pub mod bench {
 	use alloc::vec::Vec;
-
-	macro_rules! fixture {
-		($name: literal) => {
-			include_bytes!(concat!(env!("OUT_DIR"), "/", $name, ".polkavm"))
-		};
-	}
 	pub const DUMMY: &[u8] = fixture!("dummy");
 	pub const NOOP: &[u8] = fixture!("noop");
 	pub const INSTR: &[u8] = fixture!("instr_benchmark");
@@ -61,7 +58,7 @@ pub mod bench {
 mod test {
 	#[test]
 	fn out_dir_should_have_compiled_mocks() {
-		let out_dir: std::path::PathBuf = env!("OUT_DIR").into();
+		let out_dir: std::path::PathBuf = crate::FIXTURE_DIR.into();
 		assert!(out_dir.join("dummy.polkavm").exists());
 	}
 }
diff --git a/substrate/frame/revive/proc-macro/src/lib.rs b/substrate/frame/revive/proc-macro/src/lib.rs
index 7232c6342824..6814add128d9 100644
--- a/substrate/frame/revive/proc-macro/src/lib.rs
+++ b/substrate/frame/revive/proc-macro/src/lib.rs
@@ -79,6 +79,7 @@ use syn::{parse_quote, punctuated::Punctuated, spanned::Spanned, token::Comma, F
 /// - `Result<(), TrapReason>`,
 /// - `Result<ReturnErrorCode, TrapReason>`,
 /// - `Result<u32, TrapReason>`.
+/// - `Result<u64, TrapReason>`.
 ///
 /// The macro expands to `pub struct Env` declaration, with the following traits implementations:
 /// - `pallet_revive::wasm::Environment<Runtime<E>> where E: Ext`
@@ -127,6 +128,7 @@ struct HostFn {
 enum HostFnReturn {
 	Unit,
 	U32,
+	U64,
 	ReturnCode,
 }
 
@@ -134,8 +136,7 @@ impl HostFnReturn {
 	fn map_output(&self) -> TokenStream2 {
 		match self {
 			Self::Unit => quote! { |_| None },
-			Self::U32 => quote! { |ret_val| Some(ret_val) },
-			Self::ReturnCode => quote! { |ret_code| Some(ret_code.into())  },
+			_ => quote! { |ret_val| Some(ret_val.into()) },
 		}
 	}
 
@@ -143,6 +144,7 @@ impl HostFnReturn {
 		match self {
 			Self::Unit => syn::ReturnType::Default,
 			Self::U32 => parse_quote! { -> u32 },
+			Self::U64 => parse_quote! { -> u64 },
 			Self::ReturnCode => parse_quote! { -> ReturnErrorCode },
 		}
 	}
@@ -243,7 +245,8 @@ impl HostFn {
 		let msg = r#"Should return one of the following:
 				- Result<(), TrapReason>,
 				- Result<ReturnErrorCode, TrapReason>,
-				- Result<u32, TrapReason>"#;
+				- Result<u32, TrapReason>,
+				- Result<u64, TrapReason>"#;
 		let ret_ty = match item.clone().sig.output {
 			syn::ReturnType::Type(_, ty) => Ok(ty.clone()),
 			_ => Err(err(span, &msg)),
@@ -305,6 +308,7 @@ impl HostFn {
 						let returns = match ok_ty_str.as_str() {
 							"()" => Ok(HostFnReturn::Unit),
 							"u32" => Ok(HostFnReturn::U32),
+							"u64" => Ok(HostFnReturn::U64),
 							"ReturnErrorCode" => Ok(HostFnReturn::ReturnCode),
 							_ => Err(err(arg1.span(), &msg)),
 						}?;
@@ -339,50 +343,61 @@ where
 	P: Iterator<Item = &'a std::boxed::Box<syn::Pat>> + Clone,
 	I: Iterator<Item = &'a std::boxed::Box<syn::Type>> + Clone,
 {
-	const ALLOWED_REGISTERS: u32 = 6;
-	let mut registers_used = 0;
-	let mut bindings = vec![];
-	let mut idx = 0;
-	for (name, ty) in param_names.clone().zip(param_types.clone()) {
+	const ALLOWED_REGISTERS: usize = 6;
+
+	// all of them take one register but we truncate them before passing into the function
+	// it is important to not allow any type which has illegal bit patterns like 'bool'
+	if !param_types.clone().all(|ty| {
 		let syn::Type::Path(path) = &**ty else {
 			panic!("Type needs to be path");
 		};
 		let Some(ident) = path.path.get_ident() else {
 			panic!("Type needs to be ident");
 		};
-		let size = if ident == "i8" ||
-			ident == "i16" ||
-			ident == "i32" ||
-			ident == "u8" ||
-			ident == "u16" ||
-			ident == "u32"
-		{
-			1
-		} else if ident == "i64" || ident == "u64" {
-			2
-		} else {
-			panic!("Pass by value only supports primitives");
-		};
-		registers_used += size;
-		if registers_used > ALLOWED_REGISTERS {
-			return quote! {
-				let (#( #param_names, )*): (#( #param_types, )*) = memory.read_as(__a0__)?;
-			}
-		}
-		let this_reg = quote::format_ident!("__a{}__", idx);
-		let next_reg = quote::format_ident!("__a{}__", idx + 1);
-		let binding = if size == 1 {
+		matches!(ident.to_string().as_ref(), "u8" | "u16" | "u32" | "u64")
+	}) {
+		panic!("Only primitive unsigned integers are allowed as arguments to syscalls");
+	}
+
+	// too many arguments: pass as pointer to a struct in memory
+	if param_names.clone().count() > ALLOWED_REGISTERS {
+		let fields = param_names.clone().zip(param_types.clone()).map(|(name, ty)| {
 			quote! {
-				let #name = #this_reg as #ty;
+				#name: #ty,
 			}
-		} else {
-			quote! {
-				let #name = (#this_reg as #ty) | ((#next_reg as #ty) << 32);
+		});
+		return quote! {
+			#[derive(Default)]
+			#[repr(C)]
+			struct Args {
+				#(#fields)*
 			}
-		};
-		bindings.push(binding);
-		idx += size;
+			let Args { #(#param_names,)* } = {
+				let len = ::core::mem::size_of::<Args>();
+				let mut args = Args::default();
+				let ptr = &mut args as *mut Args as *mut u8;
+				// Safety
+				// 1. The struct is initialized at all times.
+				// 2. We only allow primitive integers (no bools) as arguments so every bit pattern is safe.
+				// 3. The reference doesn't outlive the args field.
+				// 4. There is only the single reference to the args field.
+				// 5. The length of the generated slice is the same as the struct.
+				let reference = unsafe {
+					::core::slice::from_raw_parts_mut(ptr, len)
+				};
+				memory.read_into_buf(__a0__ as _, reference)?;
+				args
+			};
+		}
 	}
+
+	// otherwise: one argument per register
+	let bindings = param_names.zip(param_types).enumerate().map(|(idx, (name, ty))| {
+		let reg = quote::format_ident!("__a{}__", idx);
+		quote! {
+			let #name = #reg as #ty;
+		}
+	});
 	quote! {
 		#( #bindings )*
 	}
@@ -409,7 +424,7 @@ fn expand_env(def: &EnvDef) -> TokenStream2 {
 				memory: &mut M,
 				__syscall_symbol__: &[u8],
 				__available_api_version__: ApiVersion,
-			) -> Result<Option<u32>, TrapReason>
+			) -> Result<Option<u64>, TrapReason>
 			{
 				#impls
 			}
diff --git a/substrate/frame/revive/rpc/src/tests.rs b/substrate/frame/revive/rpc/src/tests.rs
index 7734c8c57209..920318b26f71 100644
--- a/substrate/frame/revive/rpc/src/tests.rs
+++ b/substrate/frame/revive/rpc/src/tests.rs
@@ -218,6 +218,8 @@ async fn deploy_and_call() -> anyhow::Result<()> {
 	Ok(())
 }
 
+/// TODO: enable ( https://github.com/paritytech/contract-issues/issues/12 )
+#[ignore]
 #[tokio::test]
 async fn revert_call() -> anyhow::Result<()> {
 	let _lock = SHARED_RESOURCES.write();
@@ -240,6 +242,8 @@ async fn revert_call() -> anyhow::Result<()> {
 	Ok(())
 }
 
+/// TODO: enable ( https://github.com/paritytech/contract-issues/issues/12 )
+#[ignore]
 #[tokio::test]
 async fn event_logs() -> anyhow::Result<()> {
 	let _lock = SHARED_RESOURCES.write();
@@ -279,6 +283,8 @@ async fn invalid_transaction() -> anyhow::Result<()> {
 	Ok(())
 }
 
+/// TODO: enable ( https://github.com/paritytech/contract-issues/issues/12 )
+#[ignore]
 #[tokio::test]
 async fn native_evm_ratio_works() -> anyhow::Result<()> {
 	let _lock = SHARED_RESOURCES.write();
diff --git a/substrate/frame/revive/src/chain_extension.rs b/substrate/frame/revive/src/chain_extension.rs
index ccea12945054..5b3e886a5628 100644
--- a/substrate/frame/revive/src/chain_extension.rs
+++ b/substrate/frame/revive/src/chain_extension.rs
@@ -75,7 +75,7 @@ use crate::{
 	Error,
 };
 use alloc::vec::Vec;
-use codec::{Decode, MaxEncodedLen};
+use codec::Decode;
 use frame_support::weights::Weight;
 use sp_runtime::DispatchError;
 
@@ -304,16 +304,6 @@ impl<'a, 'b, E: Ext, M: ?Sized + Memory<E::T>> Environment<'a, 'b, E, M> {
 		Ok(())
 	}
 
-	/// Reads and decodes a type with a size fixed at compile time from contract memory.
-	///
-	/// This function is secure and recommended for all input types of fixed size
-	/// as long as the cost of reading the memory is included in the overall already charged
-	/// weight of the chain extension. This should usually be the case when fixed input types
-	/// are used.
-	pub fn read_as<T: Decode + MaxEncodedLen>(&mut self) -> Result<T> {
-		self.memory.read_as(self.input_ptr)
-	}
-
 	/// Reads and decodes a type with a dynamic size from contract memory.
 	///
 	/// Make sure to include `len` in your weight calculations.
diff --git a/substrate/frame/revive/src/limits.rs b/substrate/frame/revive/src/limits.rs
index 64e66382b9ab..5ce96f59c14d 100644
--- a/substrate/frame/revive/src/limits.rs
+++ b/substrate/frame/revive/src/limits.rs
@@ -129,23 +129,36 @@ pub mod code {
 			Error::<T>::CodeRejected
 		})?;
 
+		if !program.is_64_bit() {
+			log::debug!(target: LOG_TARGET, "32bit programs are not supported.");
+			Err(Error::<T>::CodeRejected)?;
+		}
+
 		// This scans the whole program but we only do it once on code deployment.
 		// It is safe to do unchecked math in u32 because the size of the program
 		// was already checked above.
-		use polkavm::program::ISA32_V1_NoSbrk as ISA;
+		use polkavm::program::ISA64_V1 as ISA;
 		let mut num_instructions: u32 = 0;
 		let mut max_basic_block_size: u32 = 0;
 		let mut basic_block_size: u32 = 0;
 		for inst in program.instructions(ISA) {
+			use polkavm::program::Instruction;
 			num_instructions += 1;
 			basic_block_size += 1;
 			if inst.kind.opcode().starts_new_basic_block() {
 				max_basic_block_size = max_basic_block_size.max(basic_block_size);
 				basic_block_size = 0;
 			}
-			if matches!(inst.kind, polkavm::program::Instruction::invalid) {
-				log::debug!(target: LOG_TARGET, "invalid instruction at offset {}", inst.offset);
-				return Err(<Error<T>>::InvalidInstruction.into())
+			match inst.kind {
+				Instruction::invalid => {
+					log::debug!(target: LOG_TARGET, "invalid instruction at offset {}", inst.offset);
+					return Err(<Error<T>>::InvalidInstruction.into())
+				},
+				Instruction::sbrk(_, _) => {
+					log::debug!(target: LOG_TARGET, "sbrk instruction is not allowed. offset {}", inst.offset);
+					return Err(<Error<T>>::InvalidInstruction.into())
+				},
+				_ => (),
 			}
 		}
 
diff --git a/substrate/frame/revive/src/wasm/mod.rs b/substrate/frame/revive/src/wasm/mod.rs
index f10c4f5fddf8..d87ec7112286 100644
--- a/substrate/frame/revive/src/wasm/mod.rs
+++ b/substrate/frame/revive/src/wasm/mod.rs
@@ -293,8 +293,15 @@ impl<T: Config> WasmBlob<T> {
 	) -> Result<PreparedCall<E>, ExecError> {
 		let mut config = polkavm::Config::default();
 		config.set_backend(Some(polkavm::BackendKind::Interpreter));
-		let engine =
-			polkavm::Engine::new(&config).expect("interpreter is available on all plattforms; qed");
+		config.set_cache_enabled(false);
+		#[cfg(feature = "std")]
+		if std::env::var_os("REVIVE_USE_COMPILER").is_some() {
+			config.set_backend(Some(polkavm::BackendKind::Compiler));
+		}
+		let engine = polkavm::Engine::new(&config).expect(
+			"on-chain (no_std) use of interpreter is hard coded.
+				interpreter is available on all plattforms; qed",
+		);
 
 		let mut module_config = polkavm::ModuleConfig::new();
 		module_config.set_page_size(limits::PAGE_SIZE);
@@ -306,6 +313,15 @@ impl<T: Config> WasmBlob<T> {
 			Error::<T>::CodeRejected
 		})?;
 
+		// This is checked at deploy time but we also want to reject pre-existing
+		// 32bit programs.
+		// TODO: Remove when we reset the test net.
+		// https://github.com/paritytech/contract-issues/issues/11
+		if !module.is_64_bit() {
+			log::debug!(target: LOG_TARGET, "32bit programs are not supported.");
+			Err(Error::<T>::CodeRejected)?;
+		}
+
 		let entry_program_counter = module
 			.exports()
 			.find(|export| export.symbol().as_bytes() == entry_point.identifier().as_bytes())
diff --git a/substrate/frame/revive/src/wasm/runtime.rs b/substrate/frame/revive/src/wasm/runtime.rs
index 3e2c83db1ebd..7ea518081e23 100644
--- a/substrate/frame/revive/src/wasm/runtime.rs
+++ b/substrate/frame/revive/src/wasm/runtime.rs
@@ -27,7 +27,7 @@ use crate::{
 	Config, Error, LOG_TARGET, SENTINEL,
 };
 use alloc::{boxed::Box, vec, vec::Vec};
-use codec::{Decode, DecodeLimit, Encode, MaxEncodedLen};
+use codec::{Decode, DecodeLimit, Encode};
 use core::{fmt, marker::PhantomData, mem};
 use frame_support::{
 	dispatch::DispatchInfo, ensure, pallet_prelude::DispatchResultWithPostInfo, parameter_types,
@@ -126,34 +126,13 @@ pub trait Memory<T: Config> {
 	///
 	/// # Note
 	///
-	/// There must be an extra benchmark for determining the influence of `len` with
-	/// regard to the overall weight.
+	/// Make sure to charge a proportional amount of weight if `len` is not fixed.
 	fn read_as_unbounded<D: Decode>(&self, ptr: u32, len: u32) -> Result<D, DispatchError> {
 		let buf = self.read(ptr, len)?;
 		let decoded = D::decode_all_with_depth_limit(MAX_DECODE_NESTING, &mut buf.as_ref())
 			.map_err(|_| DispatchError::from(Error::<T>::DecodingFailed))?;
 		Ok(decoded)
 	}
-
-	/// Reads and decodes a type with a size fixed at compile time from contract memory.
-	///
-	/// # Only use on fixed size types
-	///
-	/// Don't use this for types where the encoded size is not fixed but merely bounded. Otherwise
-	/// this implementation will out of bound access the buffer declared by the guest. Some examples
-	/// of those bounded but not fixed types: Enums with data, `BoundedVec` or any compact encoded
-	/// integer.
-	///
-	/// # Note
-	///
-	/// The weight of reading a fixed value is included in the overall weight of any
-	/// contract callable function.
-	fn read_as<D: Decode + MaxEncodedLen>(&self, ptr: u32) -> Result<D, DispatchError> {
-		let buf = self.read(ptr, D::max_encoded_len() as u32)?;
-		let decoded = D::decode_with_depth_limit(MAX_DECODE_NESTING, &mut buf.as_ref())
-			.map_err(|_| DispatchError::from(Error::<T>::DecodingFailed))?;
-		Ok(decoded)
-	}
 }
 
 /// Allows syscalls access to the PolkaVM instance they are executing in.
@@ -164,8 +143,8 @@ pub trait Memory<T: Config> {
 pub trait PolkaVmInstance<T: Config>: Memory<T> {
 	fn gas(&self) -> polkavm::Gas;
 	fn set_gas(&mut self, gas: polkavm::Gas);
-	fn read_input_regs(&self) -> (u32, u32, u32, u32, u32, u32);
-	fn write_output(&mut self, output: u32);
+	fn read_input_regs(&self) -> (u64, u64, u64, u64, u64, u64);
+	fn write_output(&mut self, output: u64);
 }
 
 // Memory implementation used in benchmarking where guest memory is mapped into the host.
@@ -214,7 +193,7 @@ impl<T: Config> PolkaVmInstance<T> for polkavm::RawInstance {
 		self.set_gas(gas)
 	}
 
-	fn read_input_regs(&self) -> (u32, u32, u32, u32, u32, u32) {
+	fn read_input_regs(&self) -> (u64, u64, u64, u64, u64, u64) {
 		(
 			self.reg(polkavm::Reg::A0),
 			self.reg(polkavm::Reg::A1),
@@ -225,7 +204,7 @@ impl<T: Config> PolkaVmInstance<T> for polkavm::RawInstance {
 		)
 	}
 
-	fn write_output(&mut self, output: u32) {
+	fn write_output(&mut self, output: u64) {
 		self.set_reg(polkavm::Reg::A0, output);
 	}
 }
diff --git a/substrate/frame/revive/uapi/Cargo.toml b/substrate/frame/revive/uapi/Cargo.toml
index 0c7461a35d69..b55391dd5d6c 100644
--- a/substrate/frame/revive/uapi/Cargo.toml
+++ b/substrate/frame/revive/uapi/Cargo.toml
@@ -20,11 +20,11 @@ codec = { features = [
 	"max-encoded-len",
 ], optional = true, workspace = true }
 
-[target.'cfg(target_arch = "riscv32")'.dependencies]
-polkavm-derive = { version = "0.14.0" }
+[target.'cfg(target_arch = "riscv64")'.dependencies]
+polkavm-derive = { version = "0.17.0" }
 
 [package.metadata.docs.rs]
-default-target = ["wasm32-unknown-unknown"]
+default-target = ["riscv64imac-unknown-none-elf"]
 
 [features]
 default = ["scale"]
diff --git a/substrate/frame/revive/uapi/src/host.rs b/substrate/frame/revive/uapi/src/host.rs
index 6b3a8b07f040..d3fd4ac8d03e 100644
--- a/substrate/frame/revive/uapi/src/host.rs
+++ b/substrate/frame/revive/uapi/src/host.rs
@@ -14,8 +14,8 @@
 use crate::{CallFlags, Result, ReturnFlags, StorageFlags};
 use paste::paste;
 
-#[cfg(target_arch = "riscv32")]
-mod riscv32;
+#[cfg(target_arch = "riscv64")]
+mod riscv64;
 
 macro_rules! hash_fn {
 	( $name:ident, $bytes:literal ) => {
diff --git a/substrate/frame/revive/uapi/src/host/riscv32.rs b/substrate/frame/revive/uapi/src/host/riscv64.rs
similarity index 93%
rename from substrate/frame/revive/uapi/src/host/riscv32.rs
rename to substrate/frame/revive/uapi/src/host/riscv64.rs
index e8b27057ed18..3cba14db6a04 100644
--- a/substrate/frame/revive/uapi/src/host/riscv32.rs
+++ b/substrate/frame/revive/uapi/src/host/riscv64.rs
@@ -26,10 +26,10 @@ mod sys {
 	mod abi {}
 
 	impl abi::FromHost for ReturnCode {
-		type Regs = (u32,);
+		type Regs = (u64,);
 
 		fn from_host((a0,): Self::Regs) -> Self {
-			ReturnCode(a0)
+			ReturnCode(a0 as _)
 		}
 	}
 
@@ -207,33 +207,33 @@ impl HostFn for HostFnImpl {
 		let (output_ptr, mut output_len) = ptr_len_or_sentinel(&mut output);
 		let deposit_limit_ptr = ptr_or_sentinel(&deposit_limit);
 		let salt_ptr = ptr_or_sentinel(&salt);
-		#[repr(packed)]
+		#[repr(C)]
 		#[allow(dead_code)]
 		struct Args {
-			code_hash: *const u8,
+			code_hash: u32,
 			ref_time_limit: u64,
 			proof_size_limit: u64,
-			deposit_limit: *const u8,
-			value: *const u8,
-			input: *const u8,
+			deposit_limit: u32,
+			value: u32,
+			input: u32,
 			input_len: u32,
-			address: *const u8,
-			output: *mut u8,
-			output_len: *mut u32,
-			salt: *const u8,
+			address: u32,
+			output: u32,
+			output_len: u32,
+			salt: u32,
 		}
 		let args = Args {
-			code_hash: code_hash.as_ptr(),
+			code_hash: code_hash.as_ptr() as _,
 			ref_time_limit,
 			proof_size_limit,
-			deposit_limit: deposit_limit_ptr,
-			value: value.as_ptr(),
-			input: input.as_ptr(),
+			deposit_limit: deposit_limit_ptr as _,
+			value: value.as_ptr() as _,
+			input: input.as_ptr() as _,
 			input_len: input.len() as _,
-			address,
-			output: output_ptr,
-			output_len: &mut output_len as *mut _,
-			salt: salt_ptr,
+			address: address as _,
+			output: output_ptr as _,
+			output_len: &mut output_len as *mut _ as _,
+			salt: salt_ptr as _,
 		};
 
 		let ret_code = { unsafe { sys::instantiate(&args as *const Args as *const _) } };
@@ -257,31 +257,31 @@ impl HostFn for HostFnImpl {
 	) -> Result {
 		let (output_ptr, mut output_len) = ptr_len_or_sentinel(&mut output);
 		let deposit_limit_ptr = ptr_or_sentinel(&deposit_limit);
-		#[repr(packed)]
+		#[repr(C)]
 		#[allow(dead_code)]
 		struct Args {
 			flags: u32,
-			callee: *const u8,
+			callee: u32,
 			ref_time_limit: u64,
 			proof_size_limit: u64,
-			deposit_limit: *const u8,
-			value: *const u8,
-			input: *const u8,
+			deposit_limit: u32,
+			value: u32,
+			input: u32,
 			input_len: u32,
-			output: *mut u8,
-			output_len: *mut u32,
+			output: u32,
+			output_len: u32,
 		}
 		let args = Args {
 			flags: flags.bits(),
-			callee: callee.as_ptr(),
+			callee: callee.as_ptr() as _,
 			ref_time_limit,
 			proof_size_limit,
-			deposit_limit: deposit_limit_ptr,
-			value: value.as_ptr(),
-			input: input.as_ptr(),
+			deposit_limit: deposit_limit_ptr as _,
+			value: value.as_ptr() as _,
+			input: input.as_ptr() as _,
 			input_len: input.len() as _,
-			output: output_ptr,
-			output_len: &mut output_len as *mut _,
+			output: output_ptr as _,
+			output_len: &mut output_len as *mut _ as _,
 		};
 
 		let ret_code = { unsafe { sys::call(&args as *const Args as *const _) } };
@@ -308,29 +308,29 @@ impl HostFn for HostFnImpl {
 	) -> Result {
 		let (output_ptr, mut output_len) = ptr_len_or_sentinel(&mut output);
 		let deposit_limit_ptr = ptr_or_sentinel(&deposit_limit);
-		#[repr(packed)]
+		#[repr(C)]
 		#[allow(dead_code)]
 		struct Args {
 			flags: u32,
-			address: *const u8,
+			address: u32,
 			ref_time_limit: u64,
 			proof_size_limit: u64,
-			deposit_limit: *const u8,
-			input: *const u8,
+			deposit_limit: u32,
+			input: u32,
 			input_len: u32,
-			output: *mut u8,
-			output_len: *mut u32,
+			output: u32,
+			output_len: u32,
 		}
 		let args = Args {
 			flags: flags.bits(),
-			address: address.as_ptr(),
+			address: address.as_ptr() as _,
 			ref_time_limit,
 			proof_size_limit,
-			deposit_limit: deposit_limit_ptr,
-			input: input.as_ptr(),
+			deposit_limit: deposit_limit_ptr as _,
+			input: input.as_ptr() as _,
 			input_len: input.len() as _,
-			output: output_ptr,
-			output_len: &mut output_len as *mut _,
+			output: output_ptr as _,
+			output_len: &mut output_len as *mut _ as _,
 		};
 
 		let ret_code = { unsafe { sys::delegate_call(&args as *const Args as *const _) } };
diff --git a/substrate/frame/revive/uapi/src/lib.rs b/substrate/frame/revive/uapi/src/lib.rs
index e660ce36ef75..91c2543bb719 100644
--- a/substrate/frame/revive/uapi/src/lib.rs
+++ b/substrate/frame/revive/uapi/src/lib.rs
@@ -65,6 +65,12 @@ impl From<ReturnErrorCode> for u32 {
 	}
 }
 
+impl From<ReturnErrorCode> for u64 {
+	fn from(error: ReturnErrorCode) -> Self {
+		u32::from(error).into()
+	}
+}
+
 define_error_codes! {
 	/// The called function trapped and has its state changes reverted.
 	/// In this case no output buffer is returned.

From 1e89a311471eba937a9552d7d1f55af1661feb08 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bastian=20K=C3=B6cher?= <git@kchr.de>
Date: Fri, 29 Nov 2024 14:09:49 +0100
Subject: [PATCH 3/5] Fix runtime api impl detection by construct runtime
 (#6665)

Construct runtime uses autoref-based specialization to fetch the
metadata about the implemented runtime apis. This is done to not fail to
compile when there are no runtime apis implemented. However, there was
an issue with detecting runtime apis when they were implemented in a
different file. The problem is solved by moving the trait implemented by
`impl_runtime_apis!` to the metadata ir crate.


Closes: https://github.com/paritytech/polkadot-sdk/issues/6659

---------

Co-authored-by: GitHub Action <action@github.com>
---
 Cargo.lock                                    |  1 +
 prdoc/pr_6665.prdoc                           | 15 ++++++
 .../src/construct_runtime/expand/metadata.rs  |  2 +
 .../procedural/src/construct_runtime/mod.rs   |  3 +-
 .../support/test/tests/runtime_metadata.rs    | 49 ++++++++++---------
 .../api/proc-macro/src/runtime_metadata.rs    |  6 +--
 substrate/primitives/api/test/Cargo.toml      |  3 +-
 .../api/test/tests/decl_and_impl.rs           |  2 +
 substrate/primitives/metadata-ir/src/lib.rs   | 10 ++++
 9 files changed, 62 insertions(+), 29 deletions(-)
 create mode 100644 prdoc/pr_6665.prdoc

diff --git a/Cargo.lock b/Cargo.lock
index e1abeea49283..5e4e9c267b08 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -25548,6 +25548,7 @@ dependencies = [
  "sp-api 26.0.0",
  "sp-consensus",
  "sp-core 28.0.0",
+ "sp-metadata-ir 0.6.0",
  "sp-runtime 31.0.1",
  "sp-state-machine 0.35.0",
  "sp-tracing 16.0.0",
diff --git a/prdoc/pr_6665.prdoc b/prdoc/pr_6665.prdoc
new file mode 100644
index 000000000000..b5aaf8a3b184
--- /dev/null
+++ b/prdoc/pr_6665.prdoc
@@ -0,0 +1,15 @@
+title: Fix runtime api impl detection by construct runtime
+doc:
+- audience: Runtime Dev
+  description: |-
+    Construct runtime uses autoref-based specialization to fetch the metadata about the implemented runtime apis. This is done to not fail to compile when there are no runtime apis implemented. However, there was an issue with detecting runtime apis when they were implemented in a different file. The problem is solved by moving the trait implemented by `impl_runtime_apis!` to the metadata ir crate.
+
+
+    Closes: https://github.com/paritytech/polkadot-sdk/issues/6659
+crates:
+- name: frame-support-procedural
+  bump: patch
+- name: sp-api-proc-macro
+  bump: patch
+- name: sp-metadata-ir
+  bump: patch
diff --git a/substrate/frame/support/procedural/src/construct_runtime/expand/metadata.rs b/substrate/frame/support/procedural/src/construct_runtime/expand/metadata.rs
index 4590a3a7f490..0b3bd5168865 100644
--- a/substrate/frame/support/procedural/src/construct_runtime/expand/metadata.rs
+++ b/substrate/frame/support/procedural/src/construct_runtime/expand/metadata.rs
@@ -113,6 +113,8 @@ pub fn expand_runtime_metadata(
 						<#extrinsic as #scrate::traits::SignedTransactionBuilder>::Extension
 					>();
 
+				use #scrate::__private::metadata_ir::InternalImplRuntimeApis;
+
 				#scrate::__private::metadata_ir::MetadataIR {
 					pallets: #scrate::__private::vec![ #(#pallets),* ],
 					extrinsic: #scrate::__private::metadata_ir::ExtrinsicMetadataIR {
diff --git a/substrate/frame/support/procedural/src/construct_runtime/mod.rs b/substrate/frame/support/procedural/src/construct_runtime/mod.rs
index 17042c248780..087faf37252d 100644
--- a/substrate/frame/support/procedural/src/construct_runtime/mod.rs
+++ b/substrate/frame/support/procedural/src/construct_runtime/mod.rs
@@ -466,7 +466,6 @@ fn construct_runtime_final_expansion(
 		// Therefore, the `Deref` trait will resolve the `runtime_metadata` from `impl_runtime_apis!`
 		// when both macros are called; and will resolve an empty `runtime_metadata` when only the `construct_runtime!`
 		// is called.
-
 		#[doc(hidden)]
 		trait InternalConstructRuntime {
 			#[inline(always)]
@@ -477,6 +476,8 @@ fn construct_runtime_final_expansion(
 		#[doc(hidden)]
 		impl InternalConstructRuntime for &#name {}
 
+		use #scrate::__private::metadata_ir::InternalImplRuntimeApis;
+
 		#outer_event
 
 		#outer_error
diff --git a/substrate/frame/support/test/tests/runtime_metadata.rs b/substrate/frame/support/test/tests/runtime_metadata.rs
index 7523a415d458..a098643abb91 100644
--- a/substrate/frame/support/test/tests/runtime_metadata.rs
+++ b/substrate/frame/support/test/tests/runtime_metadata.rs
@@ -80,34 +80,39 @@ sp_api::decl_runtime_apis! {
 	}
 }
 
-sp_api::impl_runtime_apis! {
-	impl self::Api<Block> for Runtime {
-		fn test(_data: u64) {
-			unimplemented!()
-		}
+// Module to emulate having the implementation in a different file.
+mod apis {
+	use super::{Block, BlockT, Runtime};
 
-		fn something_with_block(_: Block) -> Block {
-			unimplemented!()
-		}
+	sp_api::impl_runtime_apis! {
+		impl crate::Api<Block> for Runtime {
+			fn test(_data: u64) {
+				unimplemented!()
+			}
 
-		fn function_with_two_args(_: u64, _: Block) {
-			unimplemented!()
-		}
+			fn something_with_block(_: Block) -> Block {
+				unimplemented!()
+			}
 
-		fn same_name() {}
+			fn function_with_two_args(_: u64, _: Block) {
+				unimplemented!()
+			}
 
-		fn wild_card(_: u32) {}
-	}
+			fn same_name() {}
 
-	impl sp_api::Core<Block> for Runtime {
-		fn version() -> sp_version::RuntimeVersion {
-			unimplemented!()
-		}
-		fn execute_block(_: Block) {
-			unimplemented!()
+			fn wild_card(_: u32) {}
 		}
-		fn initialize_block(_: &<Block as BlockT>::Header) -> sp_runtime::ExtrinsicInclusionMode {
-			unimplemented!()
+
+		impl sp_api::Core<Block> for Runtime {
+			fn version() -> sp_version::RuntimeVersion {
+				unimplemented!()
+			}
+			fn execute_block(_: Block) {
+				unimplemented!()
+			}
+			fn initialize_block(_: &<Block as BlockT>::Header) -> sp_runtime::ExtrinsicInclusionMode {
+				unimplemented!()
+			}
 		}
 	}
 }
diff --git a/substrate/primitives/api/proc-macro/src/runtime_metadata.rs b/substrate/primitives/api/proc-macro/src/runtime_metadata.rs
index 6be396339259..1706f8ca6fbb 100644
--- a/substrate/primitives/api/proc-macro/src/runtime_metadata.rs
+++ b/substrate/primitives/api/proc-macro/src/runtime_metadata.rs
@@ -298,18 +298,14 @@ pub fn generate_impl_runtime_metadata(impls: &[ItemImpl]) -> Result<TokenStream2
 	// Therefore, the `Deref` trait will resolve the `runtime_metadata` from `impl_runtime_apis!`
 	// when both macros are called; and will resolve an empty `runtime_metadata` when only the
 	// `construct_runtime!` is called.
-
 	Ok(quote!(
 		#crate_::frame_metadata_enabled! {
 			#[doc(hidden)]
-			trait InternalImplRuntimeApis {
-				#[inline(always)]
+			impl #crate_::metadata_ir::InternalImplRuntimeApis for #runtime_name {
 				fn runtime_metadata(&self) -> #crate_::vec::Vec<#crate_::metadata_ir::RuntimeApiMetadataIR> {
 					#crate_::vec![ #( #metadata, )* ]
 				}
 			}
-			#[doc(hidden)]
-			impl InternalImplRuntimeApis for #runtime_name {}
 		}
 	))
 }
diff --git a/substrate/primitives/api/test/Cargo.toml b/substrate/primitives/api/test/Cargo.toml
index 1d21f23eb804..27f6dafa24bf 100644
--- a/substrate/primitives/api/test/Cargo.toml
+++ b/substrate/primitives/api/test/Cargo.toml
@@ -21,6 +21,7 @@ sp-version = { workspace = true, default-features = true }
 sp-tracing = { workspace = true, default-features = true }
 sp-runtime = { workspace = true, default-features = true }
 sp-consensus = { workspace = true, default-features = true }
+sp-metadata-ir = { workspace = true, default-features = true }
 sc-block-builder = { workspace = true, default-features = true }
 codec = { workspace = true, default-features = true }
 sp-state-machine = { workspace = true, default-features = true }
@@ -40,5 +41,5 @@ name = "bench"
 harness = false
 
 [features]
-"enable-staging-api" = []
+enable-staging-api = []
 disable-ui-tests = []
diff --git a/substrate/primitives/api/test/tests/decl_and_impl.rs b/substrate/primitives/api/test/tests/decl_and_impl.rs
index 890cf6eccdbc..2e5a078cb382 100644
--- a/substrate/primitives/api/test/tests/decl_and_impl.rs
+++ b/substrate/primitives/api/test/tests/decl_and_impl.rs
@@ -309,6 +309,8 @@ fn mock_runtime_api_works_with_advanced() {
 
 #[test]
 fn runtime_api_metadata_matches_version_implemented() {
+	use sp_metadata_ir::InternalImplRuntimeApis;
+
 	let rt = Runtime {};
 	let runtime_metadata = rt.runtime_metadata();
 
diff --git a/substrate/primitives/metadata-ir/src/lib.rs b/substrate/primitives/metadata-ir/src/lib.rs
index bf234432a1a6..dc01f7eaadb3 100644
--- a/substrate/primitives/metadata-ir/src/lib.rs
+++ b/substrate/primitives/metadata-ir/src/lib.rs
@@ -87,6 +87,16 @@ pub fn into_unstable(metadata: MetadataIR) -> RuntimeMetadataPrefixed {
 	latest.into()
 }
 
+/// INTERNAL USE ONLY
+///
+/// Special trait that is used together with `InternalConstructRuntime` by `construct_runtime!` to
+/// fetch the runtime api metadata without exploding when there is no runtime api implementation
+/// available.
+#[doc(hidden)]
+pub trait InternalImplRuntimeApis {
+	fn runtime_metadata(&self) -> alloc::vec::Vec<RuntimeApiMetadataIR>;
+}
+
 #[cfg(test)]
 mod test {
 	use super::*;

From 4e7c968ae97c66812df989117ad251cba3864632 Mon Sep 17 00:00:00 2001
From: Alexandru Vasile <60601340+lexnv@users.noreply.github.com>
Date: Fri, 29 Nov 2024 16:49:45 +0200
Subject: [PATCH 4/5] archive: Refactor `archive_storage` method into
 subscription (#6483)

This PR adapts the `archive_storage` implementation from a method to a
subscription.

This keeps the archive APIs uniform and consistent.

Builds on: https://github.com/paritytech/polkadot-sdk/pull/5997

cc @paritytech/subxt-team

---------

Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>
Co-authored-by: James Wilson <james@jsdw.me>
---
 .../client/rpc-spec-v2/src/archive/api.rs     |  13 +-
 .../client/rpc-spec-v2/src/archive/archive.rs | 202 +++----
 .../src/archive/archive_storage.rs            | 105 +---
 .../client/rpc-spec-v2/src/archive/mod.rs     |   2 +-
 .../client/rpc-spec-v2/src/archive/tests.rs   | 500 +++++++-----------
 .../rpc-spec-v2/src/chain_head/event.rs       |   3 +-
 .../client/rpc-spec-v2/src/common/events.rs   |  59 ++-
 .../client/rpc-spec-v2/src/common/storage.rs  | 151 ++++--
 substrate/client/service/src/builder.rs       |   2 -
 9 files changed, 458 insertions(+), 579 deletions(-)

diff --git a/substrate/client/rpc-spec-v2/src/archive/api.rs b/substrate/client/rpc-spec-v2/src/archive/api.rs
index dcfeaecb147b..a205d0502c93 100644
--- a/substrate/client/rpc-spec-v2/src/archive/api.rs
+++ b/substrate/client/rpc-spec-v2/src/archive/api.rs
@@ -20,8 +20,7 @@
 
 use crate::{
 	common::events::{
-		ArchiveStorageDiffEvent, ArchiveStorageDiffItem, ArchiveStorageResult,
-		PaginatedStorageQuery,
+		ArchiveStorageDiffEvent, ArchiveStorageDiffItem, ArchiveStorageEvent, StorageQuery,
 	},
 	MethodResult,
 };
@@ -100,13 +99,17 @@ pub trait ArchiveApi<Hash> {
 	/// # Unstable
 	///
 	/// This method is unstable and subject to change in the future.
-	#[method(name = "archive_unstable_storage", blocking)]
+	#[subscription(
+		name = "archive_unstable_storage" => "archive_unstable_storageEvent",
+		unsubscribe = "archive_unstable_stopStorage",
+		item = ArchiveStorageEvent,
+	)]
 	fn archive_unstable_storage(
 		&self,
 		hash: Hash,
-		items: Vec<PaginatedStorageQuery<String>>,
+		items: Vec<StorageQuery<String>>,
 		child_trie: Option<String>,
-	) -> RpcResult<ArchiveStorageResult>;
+	);
 
 	/// Returns the storage difference between two blocks.
 	///
diff --git a/substrate/client/rpc-spec-v2/src/archive/archive.rs b/substrate/client/rpc-spec-v2/src/archive/archive.rs
index 55054d91d85d..62e44a016241 100644
--- a/substrate/client/rpc-spec-v2/src/archive/archive.rs
+++ b/substrate/client/rpc-spec-v2/src/archive/archive.rs
@@ -20,13 +20,13 @@
 
 use crate::{
 	archive::{
-		archive_storage::{ArchiveStorage, ArchiveStorageDiff},
-		error::Error as ArchiveError,
-		ArchiveApiServer,
+		archive_storage::ArchiveStorageDiff, error::Error as ArchiveError, ArchiveApiServer,
 	},
-	common::events::{
-		ArchiveStorageDiffEvent, ArchiveStorageDiffItem, ArchiveStorageResult,
-		PaginatedStorageQuery,
+	common::{
+		events::{
+			ArchiveStorageDiffEvent, ArchiveStorageDiffItem, ArchiveStorageEvent, StorageQuery,
+		},
+		storage::{QueryResult, StorageSubscriptionClient},
 	},
 	hex_string, MethodResult, SubscriptionTaskExecutor,
 };
@@ -57,42 +57,12 @@ use tokio::sync::mpsc;
 
 pub(crate) const LOG_TARGET: &str = "rpc-spec-v2::archive";
 
-/// The configuration of [`Archive`].
-pub struct ArchiveConfig {
-	/// The maximum number of items the `archive_storage` can return for a descendant query before
-	/// pagination is required.
-	pub max_descendant_responses: usize,
-	/// The maximum number of queried items allowed for the `archive_storage` at a time.
-	pub max_queried_items: usize,
-}
-
-/// The maximum number of items the `archive_storage` can return for a descendant query before
-/// pagination is required.
-///
-/// Note: this is identical to the `chainHead` value.
-const MAX_DESCENDANT_RESPONSES: usize = 5;
-
-/// The maximum number of queried items allowed for the `archive_storage` at a time.
-///
-/// Note: A queried item can also be a descendant query which can return up to
-/// `MAX_DESCENDANT_RESPONSES`.
-const MAX_QUERIED_ITEMS: usize = 8;
-
 /// The buffer capacity for each storage query.
 ///
 /// This is small because the underlying JSON-RPC server has
 /// its down buffer capacity per connection as well.
 const STORAGE_QUERY_BUF: usize = 16;
 
-impl Default for ArchiveConfig {
-	fn default() -> Self {
-		Self {
-			max_descendant_responses: MAX_DESCENDANT_RESPONSES,
-			max_queried_items: MAX_QUERIED_ITEMS,
-		}
-	}
-}
-
 /// An API for archive RPC calls.
 pub struct Archive<BE: Backend<Block>, Block: BlockT, Client> {
 	/// Substrate client.
@@ -103,11 +73,6 @@ pub struct Archive<BE: Backend<Block>, Block: BlockT, Client> {
 	executor: SubscriptionTaskExecutor,
 	/// The hexadecimal encoded hash of the genesis block.
 	genesis_hash: String,
-	/// The maximum number of items the `archive_storage` can return for a descendant query before
-	/// pagination is required.
-	storage_max_descendant_responses: usize,
-	/// The maximum number of queried items allowed for the `archive_storage` at a time.
-	storage_max_queried_items: usize,
 	/// Phantom member to pin the block type.
 	_phantom: PhantomData<Block>,
 }
@@ -119,18 +84,9 @@ impl<BE: Backend<Block>, Block: BlockT, Client> Archive<BE, Block, Client> {
 		backend: Arc<BE>,
 		genesis_hash: GenesisHash,
 		executor: SubscriptionTaskExecutor,
-		config: ArchiveConfig,
 	) -> Self {
 		let genesis_hash = hex_string(&genesis_hash.as_ref());
-		Self {
-			client,
-			backend,
-			executor,
-			genesis_hash,
-			storage_max_descendant_responses: config.max_descendant_responses,
-			storage_max_queried_items: config.max_queried_items,
-			_phantom: PhantomData,
-		}
+		Self { client, backend, executor, genesis_hash, _phantom: PhantomData }
 	}
 }
 
@@ -260,47 +216,53 @@ where
 
 	fn archive_unstable_storage(
 		&self,
+		pending: PendingSubscriptionSink,
 		hash: Block::Hash,
-		items: Vec<PaginatedStorageQuery<String>>,
+		items: Vec<StorageQuery<String>>,
 		child_trie: Option<String>,
-	) -> RpcResult<ArchiveStorageResult> {
-		let items = items
-			.into_iter()
-			.map(|query| {
-				let key = StorageKey(parse_hex_param(query.key)?);
-				let pagination_start_key = query
-					.pagination_start_key
-					.map(|key| parse_hex_param(key).map(|key| StorageKey(key)))
-					.transpose()?;
-
-				// Paginated start key is only supported
-				if pagination_start_key.is_some() && !query.query_type.is_descendant_query() {
-					return Err(ArchiveError::InvalidParam(
-						"Pagination start key is only supported for descendants queries"
-							.to_string(),
-					))
-				}
+	) {
+		let mut storage_client =
+			StorageSubscriptionClient::<Client, Block, BE>::new(self.client.clone());
+
+		let fut = async move {
+			let Ok(mut sink) = pending.accept().await.map(Subscription::from) else { return };
 
-				Ok(PaginatedStorageQuery {
-					key,
-					query_type: query.query_type,
-					pagination_start_key,
+			let items = match items
+				.into_iter()
+				.map(|query| {
+					let key = StorageKey(parse_hex_param(query.key)?);
+					Ok(StorageQuery { key, query_type: query.query_type })
 				})
-			})
-			.collect::<Result<Vec<_>, ArchiveError>>()?;
+				.collect::<Result<Vec<_>, ArchiveError>>()
+			{
+				Ok(items) => items,
+				Err(error) => {
+					let _ = sink.send(&ArchiveStorageEvent::err(error.to_string()));
+					return
+				},
+			};
 
-		let child_trie = child_trie
-			.map(|child_trie| parse_hex_param(child_trie))
-			.transpose()?
-			.map(ChildInfo::new_default_from_vec);
+			let child_trie = child_trie.map(|child_trie| parse_hex_param(child_trie)).transpose();
+			let child_trie = match child_trie {
+				Ok(child_trie) => child_trie.map(ChildInfo::new_default_from_vec),
+				Err(error) => {
+					let _ = sink.send(&ArchiveStorageEvent::err(error.to_string()));
+					return
+				},
+			};
 
-		let storage_client = ArchiveStorage::new(
-			self.client.clone(),
-			self.storage_max_descendant_responses,
-			self.storage_max_queried_items,
-		);
+			let (tx, mut rx) = tokio::sync::mpsc::channel(STORAGE_QUERY_BUF);
+			let storage_fut = storage_client.generate_events(hash, items, child_trie, tx);
 
-		Ok(storage_client.handle_query(hash, items, child_trie))
+			// We don't care about the return value of this join:
+			// - process_events might encounter an error (if the client disconnected)
+			// - storage_fut might encounter an error while processing a trie queries and
+			// the error is propagated via the sink.
+			let _ = futures::future::join(storage_fut, process_storage_events(&mut rx, &mut sink))
+				.await;
+		};
+
+		self.executor.spawn("substrate-rpc-subscription", Some("rpc"), fut.boxed());
 	}
 
 	fn archive_unstable_storage_diff(
@@ -337,24 +299,74 @@ where
 			// - process_events might encounter an error (if the client disconnected)
 			// - storage_fut might encounter an error while processing a trie queries and
 			// the error is propagated via the sink.
-			let _ = futures::future::join(storage_fut, process_events(&mut rx, &mut sink)).await;
+			let _ =
+				futures::future::join(storage_fut, process_storage_diff_events(&mut rx, &mut sink))
+					.await;
 		};
 
 		self.executor.spawn("substrate-rpc-subscription", Some("rpc"), fut.boxed());
 	}
 }
 
-/// Sends all the events to the sink.
-async fn process_events(rx: &mut mpsc::Receiver<ArchiveStorageDiffEvent>, sink: &mut Subscription) {
-	while let Some(event) = rx.recv().await {
-		if event.is_done() {
-			log::debug!(target: LOG_TARGET, "Finished processing partial trie query");
-		} else if event.is_err() {
-			log::debug!(target: LOG_TARGET, "Error encountered while processing partial trie query");
+/// Sends all the events of the storage_diff method to the sink.
+async fn process_storage_diff_events(
+	rx: &mut mpsc::Receiver<ArchiveStorageDiffEvent>,
+	sink: &mut Subscription,
+) {
+	loop {
+		tokio::select! {
+			_ = sink.closed() => {
+				return
+			},
+
+			maybe_event = rx.recv() => {
+				let Some(event) = maybe_event else {
+					break;
+				};
+
+				if event.is_done() {
+					log::debug!(target: LOG_TARGET, "Finished processing partial trie query");
+				} else if event.is_err() {
+					log::debug!(target: LOG_TARGET, "Error encountered while processing partial trie query");
+				}
+
+				if sink.send(&event).await.is_err() {
+					return
+				}
+			}
 		}
+	}
+}
+
+/// Sends all the events of the storage method to the sink.
+async fn process_storage_events(rx: &mut mpsc::Receiver<QueryResult>, sink: &mut Subscription) {
+	loop {
+		tokio::select! {
+			_ = sink.closed() => {
+				break
+			}
+
+			maybe_storage = rx.recv() => {
+				let Some(event) = maybe_storage else {
+					break;
+				};
+
+				match event {
+					Ok(None) => continue,
+
+					Ok(Some(event)) =>
+						if sink.send(&ArchiveStorageEvent::result(event)).await.is_err() {
+							return
+						},
 
-		if sink.send(&event).await.is_err() {
-			return
+					Err(error) => {
+						let _ = sink.send(&ArchiveStorageEvent::err(error)).await;
+						return
+					}
+				}
+			}
 		}
 	}
+
+	let _ = sink.send(&ArchiveStorageEvent::StorageDone).await;
 }
diff --git a/substrate/client/rpc-spec-v2/src/archive/archive_storage.rs b/substrate/client/rpc-spec-v2/src/archive/archive_storage.rs
index 5a3920882f00..390db765a48f 100644
--- a/substrate/client/rpc-spec-v2/src/archive/archive_storage.rs
+++ b/substrate/client/rpc-spec-v2/src/archive/archive_storage.rs
@@ -33,114 +33,13 @@ use crate::{
 	common::{
 		events::{
 			ArchiveStorageDiffEvent, ArchiveStorageDiffItem, ArchiveStorageDiffOperationType,
-			ArchiveStorageDiffResult, ArchiveStorageDiffType, ArchiveStorageResult,
-			PaginatedStorageQuery, StorageQueryType, StorageResult,
+			ArchiveStorageDiffResult, ArchiveStorageDiffType, StorageResult,
 		},
-		storage::{IterQueryType, QueryIter, Storage},
+		storage::Storage,
 	},
 };
 use tokio::sync::mpsc;
 
-/// Generates the events of the `archive_storage` method.
-pub struct ArchiveStorage<Client, Block, BE> {
-	/// Storage client.
-	client: Storage<Client, Block, BE>,
-	/// The maximum number of responses the API can return for a descendant query at a time.
-	storage_max_descendant_responses: usize,
-	/// The maximum number of queried items allowed for the `archive_storage` at a time.
-	storage_max_queried_items: usize,
-}
-
-impl<Client, Block, BE> ArchiveStorage<Client, Block, BE> {
-	/// Constructs a new [`ArchiveStorage`].
-	pub fn new(
-		client: Arc<Client>,
-		storage_max_descendant_responses: usize,
-		storage_max_queried_items: usize,
-	) -> Self {
-		Self {
-			client: Storage::new(client),
-			storage_max_descendant_responses,
-			storage_max_queried_items,
-		}
-	}
-}
-
-impl<Client, Block, BE> ArchiveStorage<Client, Block, BE>
-where
-	Block: BlockT + 'static,
-	BE: Backend<Block> + 'static,
-	Client: StorageProvider<Block, BE> + 'static,
-{
-	/// Generate the response of the `archive_storage` method.
-	pub fn handle_query(
-		&self,
-		hash: Block::Hash,
-		mut items: Vec<PaginatedStorageQuery<StorageKey>>,
-		child_key: Option<ChildInfo>,
-	) -> ArchiveStorageResult {
-		let discarded_items = items.len().saturating_sub(self.storage_max_queried_items);
-		items.truncate(self.storage_max_queried_items);
-
-		let mut storage_results = Vec::with_capacity(items.len());
-		for item in items {
-			match item.query_type {
-				StorageQueryType::Value => {
-					match self.client.query_value(hash, &item.key, child_key.as_ref()) {
-						Ok(Some(value)) => storage_results.push(value),
-						Ok(None) => continue,
-						Err(error) => return ArchiveStorageResult::err(error),
-					}
-				},
-				StorageQueryType::Hash =>
-					match self.client.query_hash(hash, &item.key, child_key.as_ref()) {
-						Ok(Some(value)) => storage_results.push(value),
-						Ok(None) => continue,
-						Err(error) => return ArchiveStorageResult::err(error),
-					},
-				StorageQueryType::ClosestDescendantMerkleValue =>
-					match self.client.query_merkle_value(hash, &item.key, child_key.as_ref()) {
-						Ok(Some(value)) => storage_results.push(value),
-						Ok(None) => continue,
-						Err(error) => return ArchiveStorageResult::err(error),
-					},
-				StorageQueryType::DescendantsValues => {
-					match self.client.query_iter_pagination(
-						QueryIter {
-							query_key: item.key,
-							ty: IterQueryType::Value,
-							pagination_start_key: item.pagination_start_key,
-						},
-						hash,
-						child_key.as_ref(),
-						self.storage_max_descendant_responses,
-					) {
-						Ok((results, _)) => storage_results.extend(results),
-						Err(error) => return ArchiveStorageResult::err(error),
-					}
-				},
-				StorageQueryType::DescendantsHashes => {
-					match self.client.query_iter_pagination(
-						QueryIter {
-							query_key: item.key,
-							ty: IterQueryType::Hash,
-							pagination_start_key: item.pagination_start_key,
-						},
-						hash,
-						child_key.as_ref(),
-						self.storage_max_descendant_responses,
-					) {
-						Ok((results, _)) => storage_results.extend(results),
-						Err(error) => return ArchiveStorageResult::err(error),
-					}
-				},
-			};
-		}
-
-		ArchiveStorageResult::ok(storage_results, discarded_items)
-	}
-}
-
 /// Parse hex-encoded string parameter as raw bytes.
 ///
 /// If the parsing fails, returns an error propagated to the RPC method.
diff --git a/substrate/client/rpc-spec-v2/src/archive/mod.rs b/substrate/client/rpc-spec-v2/src/archive/mod.rs
index 5f020c203eab..14fa104c113a 100644
--- a/substrate/client/rpc-spec-v2/src/archive/mod.rs
+++ b/substrate/client/rpc-spec-v2/src/archive/mod.rs
@@ -32,4 +32,4 @@ pub mod archive;
 pub mod error;
 
 pub use api::ArchiveApiServer;
-pub use archive::{Archive, ArchiveConfig};
+pub use archive::Archive;
diff --git a/substrate/client/rpc-spec-v2/src/archive/tests.rs b/substrate/client/rpc-spec-v2/src/archive/tests.rs
index 994c5d28bd61..cddaafde6659 100644
--- a/substrate/client/rpc-spec-v2/src/archive/tests.rs
+++ b/substrate/client/rpc-spec-v2/src/archive/tests.rs
@@ -19,16 +19,13 @@
 use crate::{
 	common::events::{
 		ArchiveStorageDiffEvent, ArchiveStorageDiffItem, ArchiveStorageDiffOperationType,
-		ArchiveStorageDiffResult, ArchiveStorageDiffType, ArchiveStorageMethodOk,
-		ArchiveStorageResult, PaginatedStorageQuery, StorageQueryType, StorageResultType,
+		ArchiveStorageDiffResult, ArchiveStorageDiffType, ArchiveStorageEvent, StorageQuery,
+		StorageQueryType, StorageResult, StorageResultType,
 	},
 	hex_string, MethodResult,
 };
 
-use super::{
-	archive::{Archive, ArchiveConfig},
-	*,
-};
+use super::{archive::Archive, *};
 
 use assert_matches::assert_matches;
 use codec::{Decode, Encode};
@@ -55,8 +52,6 @@ use substrate_test_runtime_client::{
 
 const CHAIN_GENESIS: [u8; 32] = [0; 32];
 const INVALID_HASH: [u8; 32] = [1; 32];
-const MAX_PAGINATION_LIMIT: usize = 5;
-const MAX_QUERIED_LIMIT: usize = 5;
 const KEY: &[u8] = b":mock";
 const VALUE: &[u8] = b"hello world";
 const CHILD_STORAGE_KEY: &[u8] = b"child";
@@ -65,10 +60,7 @@ const CHILD_VALUE: &[u8] = b"child value";
 type Header = substrate_test_runtime_client::runtime::Header;
 type Block = substrate_test_runtime_client::runtime::Block;
 
-fn setup_api(
-	max_descendant_responses: usize,
-	max_queried_items: usize,
-) -> (Arc<Client<Backend>>, RpcModule<Archive<Backend, Block, Client<Backend>>>) {
+fn setup_api() -> (Arc<Client<Backend>>, RpcModule<Archive<Backend, Block, Client<Backend>>>) {
 	let child_info = ChildInfo::new_default(CHILD_STORAGE_KEY);
 	let builder = TestClientBuilder::new().add_extra_child_storage(
 		&child_info,
@@ -83,7 +75,6 @@ fn setup_api(
 		backend,
 		CHAIN_GENESIS,
 		Arc::new(TokioTestExecutor::default()),
-		ArchiveConfig { max_descendant_responses, max_queried_items },
 	)
 	.into_rpc();
 
@@ -101,7 +92,7 @@ async fn get_next_event<T: serde::de::DeserializeOwned>(sub: &mut RpcSubscriptio
 
 #[tokio::test]
 async fn archive_genesis() {
-	let (_client, api) = setup_api(MAX_PAGINATION_LIMIT, MAX_QUERIED_LIMIT);
+	let (_client, api) = setup_api();
 
 	let genesis: String =
 		api.call("archive_unstable_genesisHash", EmptyParams::new()).await.unwrap();
@@ -110,7 +101,7 @@ async fn archive_genesis() {
 
 #[tokio::test]
 async fn archive_body() {
-	let (client, api) = setup_api(MAX_PAGINATION_LIMIT, MAX_QUERIED_LIMIT);
+	let (client, api) = setup_api();
 
 	// Invalid block hash.
 	let invalid_hash = hex_string(&INVALID_HASH);
@@ -144,7 +135,7 @@ async fn archive_body() {
 
 #[tokio::test]
 async fn archive_header() {
-	let (client, api) = setup_api(MAX_PAGINATION_LIMIT, MAX_QUERIED_LIMIT);
+	let (client, api) = setup_api();
 
 	// Invalid block hash.
 	let invalid_hash = hex_string(&INVALID_HASH);
@@ -178,7 +169,7 @@ async fn archive_header() {
 
 #[tokio::test]
 async fn archive_finalized_height() {
-	let (client, api) = setup_api(MAX_PAGINATION_LIMIT, MAX_QUERIED_LIMIT);
+	let (client, api) = setup_api();
 
 	let client_height: u32 = client.info().finalized_number.saturated_into();
 
@@ -190,7 +181,7 @@ async fn archive_finalized_height() {
 
 #[tokio::test]
 async fn archive_hash_by_height() {
-	let (client, api) = setup_api(MAX_PAGINATION_LIMIT, MAX_QUERIED_LIMIT);
+	let (client, api) = setup_api();
 
 	// Genesis height.
 	let hashes: Vec<String> = api.call("archive_unstable_hashByHeight", [0]).await.unwrap();
@@ -296,7 +287,7 @@ async fn archive_hash_by_height() {
 
 #[tokio::test]
 async fn archive_call() {
-	let (client, api) = setup_api(MAX_PAGINATION_LIMIT, MAX_QUERIED_LIMIT);
+	let (client, api) = setup_api();
 	let invalid_hash = hex_string(&INVALID_HASH);
 
 	// Invalid parameter (non-hex).
@@ -355,7 +346,7 @@ async fn archive_call() {
 
 #[tokio::test]
 async fn archive_storage_hashes_values() {
-	let (client, api) = setup_api(MAX_PAGINATION_LIMIT, MAX_QUERIED_LIMIT);
+	let (client, api) = setup_api();
 
 	let block = BlockBuilderBuilder::new(&*client)
 		.on_parent_block(client.chain_info().genesis_hash)
@@ -369,42 +360,23 @@ async fn archive_storage_hashes_values() {
 	let block_hash = format!("{:?}", block.header.hash());
 	let key = hex_string(&KEY);
 
-	let items: Vec<PaginatedStorageQuery<String>> = vec![
-		PaginatedStorageQuery {
-			key: key.clone(),
-			query_type: StorageQueryType::DescendantsHashes,
-			pagination_start_key: None,
-		},
-		PaginatedStorageQuery {
-			key: key.clone(),
-			query_type: StorageQueryType::DescendantsValues,
-			pagination_start_key: None,
-		},
-		PaginatedStorageQuery {
-			key: key.clone(),
-			query_type: StorageQueryType::Hash,
-			pagination_start_key: None,
-		},
-		PaginatedStorageQuery {
-			key: key.clone(),
-			query_type: StorageQueryType::Value,
-			pagination_start_key: None,
-		},
+	let items: Vec<StorageQuery<String>> = vec![
+		StorageQuery { key: key.clone(), query_type: StorageQueryType::DescendantsHashes },
+		StorageQuery { key: key.clone(), query_type: StorageQueryType::DescendantsValues },
+		StorageQuery { key: key.clone(), query_type: StorageQueryType::Hash },
+		StorageQuery { key: key.clone(), query_type: StorageQueryType::Value },
 	];
 
-	let result: ArchiveStorageResult = api
-		.call("archive_unstable_storage", rpc_params![&block_hash, items.clone()])
+	let mut sub = api
+		.subscribe_unbounded("archive_unstable_storage", rpc_params![&block_hash, items.clone()])
 		.await
 		.unwrap();
 
-	match result {
-		ArchiveStorageResult::Ok(ArchiveStorageMethodOk { result, discarded_items }) => {
-			// Key has not been imported yet.
-			assert_eq!(result.len(), 0);
-			assert_eq!(discarded_items, 0);
-		},
-		_ => panic!("Unexpected result"),
-	};
+	// Key has not been imported yet.
+	assert_eq!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::StorageDone,
+	);
 
 	// Import a block with the given key value pair.
 	let mut builder = BlockBuilderBuilder::new(&*client)
@@ -420,32 +392,103 @@ async fn archive_storage_hashes_values() {
 	let expected_hash = format!("{:?}", Blake2Hasher::hash(&VALUE));
 	let expected_value = hex_string(&VALUE);
 
-	let result: ArchiveStorageResult = api
-		.call("archive_unstable_storage", rpc_params![&block_hash, items])
+	let mut sub = api
+		.subscribe_unbounded("archive_unstable_storage", rpc_params![&block_hash, items])
 		.await
 		.unwrap();
 
-	match result {
-		ArchiveStorageResult::Ok(ArchiveStorageMethodOk { result, discarded_items }) => {
-			assert_eq!(result.len(), 4);
-			assert_eq!(discarded_items, 0);
-
-			assert_eq!(result[0].key, key);
-			assert_eq!(result[0].result, StorageResultType::Hash(expected_hash.clone()));
-			assert_eq!(result[1].key, key);
-			assert_eq!(result[1].result, StorageResultType::Value(expected_value.clone()));
-			assert_eq!(result[2].key, key);
-			assert_eq!(result[2].result, StorageResultType::Hash(expected_hash));
-			assert_eq!(result[3].key, key);
-			assert_eq!(result[3].result, StorageResultType::Value(expected_value));
-		},
-		_ => panic!("Unexpected result"),
-	};
+	assert_eq!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::Storage(StorageResult {
+			key: key.clone(),
+			result: StorageResultType::Hash(expected_hash.clone()),
+			child_trie_key: None,
+		}),
+	);
+
+	assert_eq!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::Storage(StorageResult {
+			key: key.clone(),
+			result: StorageResultType::Value(expected_value.clone()),
+			child_trie_key: None,
+		}),
+	);
+
+	assert_eq!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::Storage(StorageResult {
+			key: key.clone(),
+			result: StorageResultType::Hash(expected_hash),
+			child_trie_key: None,
+		}),
+	);
+
+	assert_eq!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::Storage(StorageResult {
+			key: key.clone(),
+			result: StorageResultType::Value(expected_value),
+			child_trie_key: None,
+		}),
+	);
+
+	assert_matches!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::StorageDone
+	);
+}
+
+#[tokio::test]
+async fn archive_storage_hashes_values_child_trie() {
+	let (client, api) = setup_api();
+
+	// Get child storage values set in `setup_api`.
+	let child_info = hex_string(&CHILD_STORAGE_KEY);
+	let key = hex_string(&KEY);
+	let genesis_hash = format!("{:?}", client.genesis_hash());
+	let expected_hash = format!("{:?}", Blake2Hasher::hash(&CHILD_VALUE));
+	let expected_value = hex_string(&CHILD_VALUE);
+
+	let items: Vec<StorageQuery<String>> = vec![
+		StorageQuery { key: key.clone(), query_type: StorageQueryType::DescendantsHashes },
+		StorageQuery { key: key.clone(), query_type: StorageQueryType::DescendantsValues },
+	];
+	let mut sub = api
+		.subscribe_unbounded(
+			"archive_unstable_storage",
+			rpc_params![&genesis_hash, items, &child_info],
+		)
+		.await
+		.unwrap();
+
+	assert_eq!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::Storage(StorageResult {
+			key: key.clone(),
+			result: StorageResultType::Hash(expected_hash.clone()),
+			child_trie_key: Some(child_info.clone()),
+		})
+	);
+
+	assert_eq!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::Storage(StorageResult {
+			key: key.clone(),
+			result: StorageResultType::Value(expected_value.clone()),
+			child_trie_key: Some(child_info.clone()),
+		})
+	);
+
+	assert_eq!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::StorageDone,
+	);
 }
 
 #[tokio::test]
 async fn archive_storage_closest_merkle_value() {
-	let (client, api) = setup_api(MAX_PAGINATION_LIMIT, MAX_QUERIED_LIMIT);
+	let (client, api) = setup_api();
 
 	/// The core of this test.
 	///
@@ -457,55 +500,47 @@ async fn archive_storage_closest_merkle_value() {
 		api: &RpcModule<Archive<Backend, Block, Client<Backend>>>,
 		block_hash: String,
 	) -> HashMap<String, String> {
-		let result: ArchiveStorageResult = api
-			.call(
+		let mut sub = api
+			.subscribe_unbounded(
 				"archive_unstable_storage",
 				rpc_params![
 					&block_hash,
 					vec![
-						PaginatedStorageQuery {
+						StorageQuery {
 							key: hex_string(b":AAAA"),
 							query_type: StorageQueryType::ClosestDescendantMerkleValue,
-							pagination_start_key: None,
 						},
-						PaginatedStorageQuery {
+						StorageQuery {
 							key: hex_string(b":AAAB"),
 							query_type: StorageQueryType::ClosestDescendantMerkleValue,
-							pagination_start_key: None,
 						},
 						// Key with descendant.
-						PaginatedStorageQuery {
+						StorageQuery {
 							key: hex_string(b":A"),
 							query_type: StorageQueryType::ClosestDescendantMerkleValue,
-							pagination_start_key: None,
 						},
-						PaginatedStorageQuery {
+						StorageQuery {
 							key: hex_string(b":AA"),
 							query_type: StorageQueryType::ClosestDescendantMerkleValue,
-							pagination_start_key: None,
 						},
 						// Keys below this comment do not produce a result.
 						// Key that exceed the keyspace of the trie.
-						PaginatedStorageQuery {
+						StorageQuery {
 							key: hex_string(b":AAAAX"),
 							query_type: StorageQueryType::ClosestDescendantMerkleValue,
-							pagination_start_key: None,
 						},
-						PaginatedStorageQuery {
+						StorageQuery {
 							key: hex_string(b":AAABX"),
 							query_type: StorageQueryType::ClosestDescendantMerkleValue,
-							pagination_start_key: None,
 						},
 						// Key that are not part of the trie.
-						PaginatedStorageQuery {
+						StorageQuery {
 							key: hex_string(b":AAX"),
 							query_type: StorageQueryType::ClosestDescendantMerkleValue,
-							pagination_start_key: None,
 						},
-						PaginatedStorageQuery {
+						StorageQuery {
 							key: hex_string(b":AAAX"),
 							query_type: StorageQueryType::ClosestDescendantMerkleValue,
-							pagination_start_key: None,
 						},
 					]
 				],
@@ -513,19 +548,21 @@ async fn archive_storage_closest_merkle_value() {
 			.await
 			.unwrap();
 
-		let merkle_values: HashMap<_, _> = match result {
-			ArchiveStorageResult::Ok(ArchiveStorageMethodOk { result, .. }) => result
-				.into_iter()
-				.map(|res| {
-					let value = match res.result {
+		let mut merkle_values = HashMap::new();
+		loop {
+			let event = get_next_event::<ArchiveStorageEvent>(&mut sub).await;
+			match event {
+				ArchiveStorageEvent::Storage(result) => {
+					let str_result = match result.result {
 						StorageResultType::ClosestDescendantMerkleValue(value) => value,
-						_ => panic!("Unexpected StorageResultType"),
+						_ => panic!("Unexpected result type"),
 					};
-					(res.key, value)
-				})
-				.collect(),
-			_ => panic!("Unexpected result"),
-		};
+					merkle_values.insert(result.key, str_result);
+				},
+				ArchiveStorageEvent::StorageError(err) => panic!("Unexpected error {err:?}"),
+				ArchiveStorageEvent::StorageDone => break,
+			}
+		}
 
 		// Response for AAAA, AAAB, A and AA.
 		assert_eq!(merkle_values.len(), 4);
@@ -604,9 +641,9 @@ async fn archive_storage_closest_merkle_value() {
 }
 
 #[tokio::test]
-async fn archive_storage_paginate_iterations() {
+async fn archive_storage_iterations() {
 	// 1 iteration allowed before pagination kicks in.
-	let (client, api) = setup_api(1, MAX_QUERIED_LIMIT);
+	let (client, api) = setup_api();
 
 	// Import a new block with storage changes.
 	let mut builder = BlockBuilderBuilder::new(&*client)
@@ -625,237 +662,94 @@ async fn archive_storage_paginate_iterations() {
 
 	// Calling with an invalid hash.
 	let invalid_hash = hex_string(&INVALID_HASH);
-	let result: ArchiveStorageResult = api
-		.call(
+	let mut sub = api
+		.subscribe_unbounded(
 			"archive_unstable_storage",
 			rpc_params![
 				&invalid_hash,
-				vec![PaginatedStorageQuery {
-					key: hex_string(b":m"),
-					query_type: StorageQueryType::DescendantsValues,
-					pagination_start_key: None,
-				}]
-			],
-		)
-		.await
-		.unwrap();
-	match result {
-		ArchiveStorageResult::Err(_) => (),
-		_ => panic!("Unexpected result"),
-	};
-
-	// Valid call with storage at the key.
-	let result: ArchiveStorageResult = api
-		.call(
-			"archive_unstable_storage",
-			rpc_params![
-				&block_hash,
-				vec![PaginatedStorageQuery {
-					key: hex_string(b":m"),
-					query_type: StorageQueryType::DescendantsValues,
-					pagination_start_key: None,
-				}]
-			],
-		)
-		.await
-		.unwrap();
-	match result {
-		ArchiveStorageResult::Ok(ArchiveStorageMethodOk { result, discarded_items }) => {
-			assert_eq!(result.len(), 1);
-			assert_eq!(discarded_items, 0);
-
-			assert_eq!(result[0].key, hex_string(b":m"));
-			assert_eq!(result[0].result, StorageResultType::Value(hex_string(b"a")));
-		},
-		_ => panic!("Unexpected result"),
-	};
-
-	// Continue with pagination.
-	let result: ArchiveStorageResult = api
-		.call(
-			"archive_unstable_storage",
-			rpc_params![
-				&block_hash,
-				vec![PaginatedStorageQuery {
-					key: hex_string(b":m"),
-					query_type: StorageQueryType::DescendantsValues,
-					pagination_start_key: Some(hex_string(b":m")),
-				}]
-			],
-		)
-		.await
-		.unwrap();
-	match result {
-		ArchiveStorageResult::Ok(ArchiveStorageMethodOk { result, discarded_items }) => {
-			assert_eq!(result.len(), 1);
-			assert_eq!(discarded_items, 0);
-
-			assert_eq!(result[0].key, hex_string(b":mo"));
-			assert_eq!(result[0].result, StorageResultType::Value(hex_string(b"ab")));
-		},
-		_ => panic!("Unexpected result"),
-	};
-
-	// Continue with pagination.
-	let result: ArchiveStorageResult = api
-		.call(
-			"archive_unstable_storage",
-			rpc_params![
-				&block_hash,
-				vec![PaginatedStorageQuery {
+				vec![StorageQuery {
 					key: hex_string(b":m"),
 					query_type: StorageQueryType::DescendantsValues,
-					pagination_start_key: Some(hex_string(b":mo")),
 				}]
 			],
 		)
 		.await
 		.unwrap();
-	match result {
-		ArchiveStorageResult::Ok(ArchiveStorageMethodOk { result, discarded_items }) => {
-			assert_eq!(result.len(), 1);
-			assert_eq!(discarded_items, 0);
-
-			assert_eq!(result[0].key, hex_string(b":moD"));
-			assert_eq!(result[0].result, StorageResultType::Value(hex_string(b"abcmoD")));
-		},
-		_ => panic!("Unexpected result"),
-	};
 
-	// Continue with pagination.
-	let result: ArchiveStorageResult = api
-		.call(
-			"archive_unstable_storage",
-			rpc_params![
-				&block_hash,
-				vec![PaginatedStorageQuery {
-					key: hex_string(b":m"),
-					query_type: StorageQueryType::DescendantsValues,
-					pagination_start_key: Some(hex_string(b":moD")),
-				}]
-			],
-		)
-		.await
-		.unwrap();
-	match result {
-		ArchiveStorageResult::Ok(ArchiveStorageMethodOk { result, discarded_items }) => {
-			assert_eq!(result.len(), 1);
-			assert_eq!(discarded_items, 0);
-
-			assert_eq!(result[0].key, hex_string(b":moc"));
-			assert_eq!(result[0].result, StorageResultType::Value(hex_string(b"abc")));
-		},
-		_ => panic!("Unexpected result"),
-	};
+	assert_matches!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::StorageError(_)
+	);
 
-	// Continue with pagination.
-	let result: ArchiveStorageResult = api
-		.call(
+	// Valid call with storage at the key.
+	let mut sub = api
+		.subscribe_unbounded(
 			"archive_unstable_storage",
 			rpc_params![
 				&block_hash,
-				vec![PaginatedStorageQuery {
+				vec![StorageQuery {
 					key: hex_string(b":m"),
 					query_type: StorageQueryType::DescendantsValues,
-					pagination_start_key: Some(hex_string(b":moc")),
 				}]
 			],
 		)
 		.await
 		.unwrap();
-	match result {
-		ArchiveStorageResult::Ok(ArchiveStorageMethodOk { result, discarded_items }) => {
-			assert_eq!(result.len(), 1);
-			assert_eq!(discarded_items, 0);
 
-			assert_eq!(result[0].key, hex_string(b":mock"));
-			assert_eq!(result[0].result, StorageResultType::Value(hex_string(b"abcd")));
-		},
-		_ => panic!("Unexpected result"),
-	};
+	assert_eq!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::Storage(StorageResult {
+			key: hex_string(b":m"),
+			result: StorageResultType::Value(hex_string(b"a")),
+			child_trie_key: None,
+		})
+	);
 
-	// Continue with pagination until no keys are returned.
-	let result: ArchiveStorageResult = api
-		.call(
-			"archive_unstable_storage",
-			rpc_params![
-				&block_hash,
-				vec![PaginatedStorageQuery {
-					key: hex_string(b":m"),
-					query_type: StorageQueryType::DescendantsValues,
-					pagination_start_key: Some(hex_string(b":mock")),
-				}]
-			],
-		)
-		.await
-		.unwrap();
-	match result {
-		ArchiveStorageResult::Ok(ArchiveStorageMethodOk { result, discarded_items }) => {
-			assert_eq!(result.len(), 0);
-			assert_eq!(discarded_items, 0);
-		},
-		_ => panic!("Unexpected result"),
-	};
-}
+	assert_eq!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::Storage(StorageResult {
+			key: hex_string(b":mo"),
+			result: StorageResultType::Value(hex_string(b"ab")),
+			child_trie_key: None,
+		})
+	);
 
-#[tokio::test]
-async fn archive_storage_discarded_items() {
-	// One query at a time
-	let (client, api) = setup_api(MAX_PAGINATION_LIMIT, 1);
+	assert_eq!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::Storage(StorageResult {
+			key: hex_string(b":moD"),
+			result: StorageResultType::Value(hex_string(b"abcmoD")),
+			child_trie_key: None,
+		})
+	);
 
-	// Import a new block with storage changes.
-	let mut builder = BlockBuilderBuilder::new(&*client)
-		.on_parent_block(client.chain_info().genesis_hash)
-		.with_parent_block_number(0)
-		.build()
-		.unwrap();
-	builder.push_storage_change(b":m".to_vec(), Some(b"a".to_vec())).unwrap();
-	let block = builder.build().unwrap().block;
-	let block_hash = format!("{:?}", block.header.hash());
-	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+	assert_eq!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::Storage(StorageResult {
+			key: hex_string(b":moc"),
+			result: StorageResultType::Value(hex_string(b"abc")),
+			child_trie_key: None,
+		})
+	);
 
-	// Valid call with storage at the key.
-	let result: ArchiveStorageResult = api
-		.call(
-			"archive_unstable_storage",
-			rpc_params![
-				&block_hash,
-				vec![
-					PaginatedStorageQuery {
-						key: hex_string(b":m"),
-						query_type: StorageQueryType::Value,
-						pagination_start_key: None,
-					},
-					PaginatedStorageQuery {
-						key: hex_string(b":m"),
-						query_type: StorageQueryType::Hash,
-						pagination_start_key: None,
-					},
-					PaginatedStorageQuery {
-						key: hex_string(b":m"),
-						query_type: StorageQueryType::Hash,
-						pagination_start_key: None,
-					}
-				]
-			],
-		)
-		.await
-		.unwrap();
-	match result {
-		ArchiveStorageResult::Ok(ArchiveStorageMethodOk { result, discarded_items }) => {
-			assert_eq!(result.len(), 1);
-			assert_eq!(discarded_items, 2);
+	assert_eq!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::Storage(StorageResult {
+			key: hex_string(b":mock"),
+			result: StorageResultType::Value(hex_string(b"abcd")),
+			child_trie_key: None,
+		})
+	);
 
-			assert_eq!(result[0].key, hex_string(b":m"));
-			assert_eq!(result[0].result, StorageResultType::Value(hex_string(b"a")));
-		},
-		_ => panic!("Unexpected result"),
-	};
+	assert_matches!(
+		get_next_event::<ArchiveStorageEvent>(&mut sub).await,
+		ArchiveStorageEvent::StorageDone
+	);
 }
 
 #[tokio::test]
 async fn archive_storage_diff_main_trie() {
-	let (client, api) = setup_api(MAX_PAGINATION_LIMIT, MAX_QUERIED_LIMIT);
+	let (client, api) = setup_api();
 
 	let mut builder = BlockBuilderBuilder::new(&*client)
 		.on_parent_block(client.chain_info().genesis_hash)
@@ -965,7 +859,7 @@ async fn archive_storage_diff_main_trie() {
 
 #[tokio::test]
 async fn archive_storage_diff_no_changes() {
-	let (client, api) = setup_api(MAX_PAGINATION_LIMIT, MAX_QUERIED_LIMIT);
+	let (client, api) = setup_api();
 
 	// Build 2 identical blocks.
 	let mut builder = BlockBuilderBuilder::new(&*client)
@@ -1012,7 +906,7 @@ async fn archive_storage_diff_no_changes() {
 
 #[tokio::test]
 async fn archive_storage_diff_deleted_changes() {
-	let (client, api) = setup_api(MAX_PAGINATION_LIMIT, MAX_QUERIED_LIMIT);
+	let (client, api) = setup_api();
 
 	// Blocks are imported as forks.
 	let mut builder = BlockBuilderBuilder::new(&*client)
@@ -1079,7 +973,7 @@ async fn archive_storage_diff_deleted_changes() {
 #[tokio::test]
 async fn archive_storage_diff_invalid_params() {
 	let invalid_hash = hex_string(&INVALID_HASH);
-	let (_, api) = setup_api(MAX_PAGINATION_LIMIT, MAX_QUERIED_LIMIT);
+	let (_, api) = setup_api();
 
 	// Invalid shape for parameters.
 	let items: Vec<ArchiveStorageDiffItem<String>> = Vec::new();
diff --git a/substrate/client/rpc-spec-v2/src/chain_head/event.rs b/substrate/client/rpc-spec-v2/src/chain_head/event.rs
index bd9863060910..de74145a3f08 100644
--- a/substrate/client/rpc-spec-v2/src/chain_head/event.rs
+++ b/substrate/client/rpc-spec-v2/src/chain_head/event.rs
@@ -235,7 +235,7 @@ pub struct OperationCallDone {
 	pub output: String,
 }
 
-/// The response of the `chainHead_call` method.
+/// The response of the `chainHead_storage` method.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct OperationStorageItems {
@@ -536,6 +536,7 @@ mod tests {
 				items: vec![StorageResult {
 					key: "0x1".into(),
 					result: StorageResultType::Value("0x123".to_string()),
+					child_trie_key: None,
 				}],
 			});
 
diff --git a/substrate/client/rpc-spec-v2/src/common/events.rs b/substrate/client/rpc-spec-v2/src/common/events.rs
index 198a60bf4cac..44f722c0c61b 100644
--- a/substrate/client/rpc-spec-v2/src/common/events.rs
+++ b/substrate/client/rpc-spec-v2/src/common/events.rs
@@ -78,6 +78,10 @@ pub struct StorageResult {
 	/// The result of the query.
 	#[serde(flatten)]
 	pub result: StorageResultType,
+	/// The child trie key if provided.
+	#[serde(skip_serializing_if = "Option::is_none")]
+	#[serde(default)]
+	pub child_trie_key: Option<String>,
 }
 
 /// The type of the storage query.
@@ -105,23 +109,41 @@ pub struct StorageResultErr {
 
 /// The result of a storage call.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum ArchiveStorageResult {
+#[serde(rename_all = "camelCase")]
+#[serde(tag = "event")]
+pub enum ArchiveStorageEvent {
 	/// Query generated a result.
-	Ok(ArchiveStorageMethodOk),
+	Storage(StorageResult),
 	/// Query encountered an error.
-	Err(ArchiveStorageMethodErr),
+	StorageError(ArchiveStorageMethodErr),
+	/// Operation storage is done.
+	StorageDone,
 }
 
-impl ArchiveStorageResult {
-	/// Create a new `ArchiveStorageResult::Ok` result.
-	pub fn ok(result: Vec<StorageResult>, discarded_items: usize) -> Self {
-		Self::Ok(ArchiveStorageMethodOk { result, discarded_items })
+impl ArchiveStorageEvent {
+	/// Create a new `ArchiveStorageEvent::StorageErr` event.
+	pub fn err(error: String) -> Self {
+		Self::StorageError(ArchiveStorageMethodErr { error })
 	}
 
-	/// Create a new `ArchiveStorageResult::Err` result.
-	pub fn err(error: String) -> Self {
-		Self::Err(ArchiveStorageMethodErr { error })
+	/// Create a new `ArchiveStorageEvent::StorageResult` event.
+	pub fn result(result: StorageResult) -> Self {
+		Self::Storage(result)
+	}
+
+	/// Checks if the event is a `StorageDone` event.
+	pub fn is_done(&self) -> bool {
+		matches!(self, Self::StorageDone)
+	}
+
+	/// Checks if the event is a `StorageErr` event.
+	pub fn is_err(&self) -> bool {
+		matches!(self, Self::StorageError(_))
+	}
+
+	/// Checks if the event is a `StorageResult` event.
+	pub fn is_result(&self) -> bool {
+		matches!(self, Self::Storage(_))
 	}
 }
 
@@ -354,8 +376,11 @@ mod tests {
 	#[test]
 	fn storage_result() {
 		// Item with Value.
-		let item =
-			StorageResult { key: "0x1".into(), result: StorageResultType::Value("res".into()) };
+		let item = StorageResult {
+			key: "0x1".into(),
+			result: StorageResultType::Value("res".into()),
+			child_trie_key: None,
+		};
 		// Encode
 		let ser = serde_json::to_string(&item).unwrap();
 		let exp = r#"{"key":"0x1","value":"res"}"#;
@@ -365,8 +390,11 @@ mod tests {
 		assert_eq!(dec, item);
 
 		// Item with Hash.
-		let item =
-			StorageResult { key: "0x1".into(), result: StorageResultType::Hash("res".into()) };
+		let item = StorageResult {
+			key: "0x1".into(),
+			result: StorageResultType::Hash("res".into()),
+			child_trie_key: None,
+		};
 		// Encode
 		let ser = serde_json::to_string(&item).unwrap();
 		let exp = r#"{"key":"0x1","hash":"res"}"#;
@@ -379,6 +407,7 @@ mod tests {
 		let item = StorageResult {
 			key: "0x1".into(),
 			result: StorageResultType::ClosestDescendantMerkleValue("res".into()),
+			child_trie_key: None,
 		};
 		// Encode
 		let ser = serde_json::to_string(&item).unwrap();
diff --git a/substrate/client/rpc-spec-v2/src/common/storage.rs b/substrate/client/rpc-spec-v2/src/common/storage.rs
index 673e20b2bc78..a1e34d51530e 100644
--- a/substrate/client/rpc-spec-v2/src/common/storage.rs
+++ b/substrate/client/rpc-spec-v2/src/common/storage.rs
@@ -24,7 +24,7 @@ use sc_client_api::{Backend, ChildInfo, StorageKey, StorageProvider};
 use sp_runtime::traits::Block as BlockT;
 use tokio::sync::mpsc;
 
-use super::events::{StorageResult, StorageResultType};
+use super::events::{StorageQuery, StorageQueryType, StorageResult, StorageResultType};
 use crate::hex_string;
 
 /// Call into the storage of blocks.
@@ -70,9 +70,6 @@ pub enum IterQueryType {
 /// The result of making a query call.
 pub type QueryResult = Result<Option<StorageResult>, String>;
 
-/// The result of iterating over keys.
-pub type QueryIterResult = Result<(Vec<StorageResult>, Option<QueryIter>), String>;
-
 impl<Client, Block, BE> Storage<Client, Block, BE>
 where
 	Block: BlockT + 'static,
@@ -97,6 +94,7 @@ where
 				QueryResult::Ok(opt.map(|storage_data| StorageResult {
 					key: hex_string(&key.0),
 					result: StorageResultType::Value(hex_string(&storage_data.0)),
+					child_trie_key: child_key.map(|c| hex_string(&c.storage_key())),
 				}))
 			})
 			.unwrap_or_else(|error| QueryResult::Err(error.to_string()))
@@ -120,6 +118,7 @@ where
 				QueryResult::Ok(opt.map(|storage_data| StorageResult {
 					key: hex_string(&key.0),
 					result: StorageResultType::Hash(hex_string(&storage_data.as_ref())),
+					child_trie_key: child_key.map(|c| hex_string(&c.storage_key())),
 				}))
 			})
 			.unwrap_or_else(|error| QueryResult::Err(error.to_string()))
@@ -149,6 +148,7 @@ where
 					StorageResult {
 						key: hex_string(&key.0),
 						result: StorageResultType::ClosestDescendantMerkleValue(result),
+						child_trie_key: child_key.map(|c| hex_string(&c.storage_key())),
 					}
 				}))
 			})
@@ -199,56 +199,6 @@ where
 		}
 	}
 
-	/// Iterate over at most the provided number of keys.
-	///
-	/// Returns the storage result with a potential next key to resume iteration.
-	pub fn query_iter_pagination(
-		&self,
-		query: QueryIter,
-		hash: Block::Hash,
-		child_key: Option<&ChildInfo>,
-		count: usize,
-	) -> QueryIterResult {
-		let QueryIter { ty, query_key, pagination_start_key } = query;
-
-		let mut keys_iter = if let Some(child_key) = child_key {
-			self.client.child_storage_keys(
-				hash,
-				child_key.to_owned(),
-				Some(&query_key),
-				pagination_start_key.as_ref(),
-			)
-		} else {
-			self.client.storage_keys(hash, Some(&query_key), pagination_start_key.as_ref())
-		}
-		.map_err(|err| err.to_string())?;
-
-		let mut ret = Vec::with_capacity(count);
-		let mut next_pagination_key = None;
-		for _ in 0..count {
-			let Some(key) = keys_iter.next() else { break };
-
-			next_pagination_key = Some(key.clone());
-
-			let result = match ty {
-				IterQueryType::Value => self.query_value(hash, &key, child_key),
-				IterQueryType::Hash => self.query_hash(hash, &key, child_key),
-			}?;
-
-			if let Some(value) = result {
-				ret.push(value);
-			}
-		}
-
-		// Save the next key if any to continue the iteration.
-		let maybe_next_query = keys_iter.next().map(|_| QueryIter {
-			ty,
-			query_key,
-			pagination_start_key: next_pagination_key,
-		});
-		Ok((ret, maybe_next_query))
-	}
-
 	/// Raw iterator over the keys.
 	pub fn raw_keys_iter(
 		&self,
@@ -264,3 +214,96 @@ where
 		keys_iter.map_err(|err| err.to_string())
 	}
 }
+
+/// Generates storage events for `chainHead_storage` and `archive_storage` subscriptions.
+pub struct StorageSubscriptionClient<Client, Block, BE> {
+	/// Storage client.
+	client: Storage<Client, Block, BE>,
+	_phandom: PhantomData<(BE, Block)>,
+}
+
+impl<Client, Block, BE> Clone for StorageSubscriptionClient<Client, Block, BE> {
+	fn clone(&self) -> Self {
+		Self { client: self.client.clone(), _phandom: PhantomData }
+	}
+}
+
+impl<Client, Block, BE> StorageSubscriptionClient<Client, Block, BE> {
+	/// Constructs a new [`StorageSubscriptionClient`].
+	pub fn new(client: Arc<Client>) -> Self {
+		Self { client: Storage::new(client), _phandom: PhantomData }
+	}
+}
+
+impl<Client, Block, BE> StorageSubscriptionClient<Client, Block, BE>
+where
+	Block: BlockT + 'static,
+	BE: Backend<Block> + 'static,
+	Client: StorageProvider<Block, BE> + Send + Sync + 'static,
+{
+	/// Generate storage events to the provided sender.
+	pub async fn generate_events(
+		&mut self,
+		hash: Block::Hash,
+		items: Vec<StorageQuery<StorageKey>>,
+		child_key: Option<ChildInfo>,
+		tx: mpsc::Sender<QueryResult>,
+	) -> Result<(), tokio::task::JoinError> {
+		let this = self.clone();
+
+		tokio::task::spawn_blocking(move || {
+			for item in items {
+				match item.query_type {
+					StorageQueryType::Value => {
+						let rp = this.client.query_value(hash, &item.key, child_key.as_ref());
+						if tx.blocking_send(rp).is_err() {
+							break;
+						}
+					},
+					StorageQueryType::Hash => {
+						let rp = this.client.query_hash(hash, &item.key, child_key.as_ref());
+						if tx.blocking_send(rp).is_err() {
+							break;
+						}
+					},
+					StorageQueryType::ClosestDescendantMerkleValue => {
+						let rp =
+							this.client.query_merkle_value(hash, &item.key, child_key.as_ref());
+						if tx.blocking_send(rp).is_err() {
+							break;
+						}
+					},
+					StorageQueryType::DescendantsValues => {
+						let query = QueryIter {
+							query_key: item.key,
+							ty: IterQueryType::Value,
+							pagination_start_key: None,
+						};
+						this.client.query_iter_pagination_with_producer(
+							query,
+							hash,
+							child_key.as_ref(),
+							&tx,
+						)
+					},
+					StorageQueryType::DescendantsHashes => {
+						let query = QueryIter {
+							query_key: item.key,
+							ty: IterQueryType::Hash,
+							pagination_start_key: None,
+						};
+						this.client.query_iter_pagination_with_producer(
+							query,
+							hash,
+							child_key.as_ref(),
+							&tx,
+						)
+					},
+				}
+			}
+		})
+		.await?;
+
+		Ok(())
+	}
+}
diff --git a/substrate/client/service/src/builder.rs b/substrate/client/service/src/builder.rs
index 027a444012af..a47a05c0a190 100644
--- a/substrate/client/service/src/builder.rs
+++ b/substrate/client/service/src/builder.rs
@@ -756,8 +756,6 @@ where
 			backend.clone(),
 			genesis_hash,
 			task_executor.clone(),
-			// Defaults to sensible limits for the `Archive`.
-			sc_rpc_spec_v2::archive::ArchiveConfig::default(),
 		)
 		.into_rpc();
 		rpc_api.merge(archive_v2).map_err(|e| Error::Application(e.into()))?;

From 1d519a1054d2edb8fc0b868eba6318fb3d448b33 Mon Sep 17 00:00:00 2001
From: Pavlo Khrystenko <45178695+pkhry@users.noreply.github.com>
Date: Fri, 29 Nov 2024 16:24:58 +0100
Subject: [PATCH 5/5] Update scale-info to 2.11.6 (#6681)

# Description

Updates scale-info to from 2.11.5 2.11.6, so that generated code is
annotated with `allow(deprecated)`
Pre-requisite for https://github.com/paritytech/polkadot-sdk/pull/6312
---
 Cargo.lock          |   8 +-
 Cargo.toml          |   2 +-
 prdoc/pr_6681.prdoc | 406 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 411 insertions(+), 5 deletions(-)
 create mode 100644 prdoc/pr_6681.prdoc

diff --git a/Cargo.lock b/Cargo.lock
index 5e4e9c267b08..1fe2d766f16a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -23715,9 +23715,9 @@ dependencies = [
 
 [[package]]
 name = "scale-info"
-version = "2.11.5"
+version = "2.11.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1aa7ffc1c0ef49b0452c6e2986abf2b07743320641ffd5fc63d552458e3b779b"
+checksum = "346a3b32eba2640d17a9cb5927056b08f3de90f65b72fe09402c2ad07d684d0b"
 dependencies = [
  "bitvec",
  "cfg-if",
@@ -23729,9 +23729,9 @@ dependencies = [
 
 [[package]]
 name = "scale-info-derive"
-version = "2.11.5"
+version = "2.11.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46385cc24172cf615450267463f937c10072516359b3ff1cb24228a4a08bf951"
+checksum = "c6630024bf739e2179b91fb424b28898baf819414262c5d376677dbff1fe7ebf"
 dependencies = [
  "proc-macro-crate 3.1.0",
  "proc-macro2 1.0.86",
diff --git a/Cargo.toml b/Cargo.toml
index 964964908a9b..ecc385504181 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1197,7 +1197,7 @@ sc-tracing-proc-macro = { path = "substrate/client/tracing/proc-macro", default-
 sc-transaction-pool = { path = "substrate/client/transaction-pool", default-features = false }
 sc-transaction-pool-api = { path = "substrate/client/transaction-pool/api", default-features = false }
 sc-utils = { path = "substrate/client/utils", default-features = false }
-scale-info = { version = "2.11.1", default-features = false }
+scale-info = { version = "2.11.6", default-features = false }
 schemars = { version = "0.8.13", default-features = false }
 schnellru = { version = "0.2.3" }
 schnorrkel = { version = "0.11.4", default-features = false }
diff --git a/prdoc/pr_6681.prdoc b/prdoc/pr_6681.prdoc
new file mode 100644
index 000000000000..93a967d4a66c
--- /dev/null
+++ b/prdoc/pr_6681.prdoc
@@ -0,0 +1,406 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: update scale-info to 2.11.6
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      Updates scale-info to 2.11.1 from 2.11.5. 
+      Updated version of scale-info annotates generated code with `allow(deprecated)`
+
+crates:
+  - name: bridge-runtime-common
+    bump: none
+  - name: bp-header-chain
+    bump: none
+  - name: bp-runtime
+    bump: none
+  - name: frame-support
+    bump: none
+  - name: sp-core
+    bump: none
+  - name: sp-trie
+    bump: none
+  - name: sp-runtime
+    bump: none
+  - name: sp-application-crypto
+    bump: none
+  - name: sp-arithmetic
+    bump: none
+  - name: sp-weights
+    bump: none
+  - name: sp-api
+    bump: none
+  - name: sp-metadata-ir
+    bump: none
+  - name: sp-version
+    bump: none
+  - name: sp-inherents
+    bump: none
+  - name: frame-executive
+    bump: none
+  - name: frame-system
+    bump: none
+  - name: pallet-balances
+    bump: none
+  - name: frame-benchmarking
+    bump: none
+  - name: pallet-migrations
+    bump: none
+  - name: cumulus-pallet-parachain-system
+    bump: none
+  - name: cumulus-primitives-core
+    bump: none
+  - name: polkadot-core-primitives
+    bump: none
+  - name: polkadot-parachain-primitives
+    bump: none
+  - name: polkadot-primitives
+    bump: none
+  - name: sp-authority-discovery 
+    bump: none
+  - name: sp-consensus-slots
+    bump: none
+  - name: sp-staking
+    bump: none
+  - name: staging-xcm
+    bump: none
+  - name: cumulus-primitives-parachain-inherent
+    bump: none
+  - name: pallet-message-queue
+    bump: none
+  - name: polkadot-runtime-common
+    bump: none
+  - name: frame-election-provider-support
+    bump: none
+  - name: sp-npos-elections
+    bump: none
+  - name: sp-consensus-grandpa
+    bump: none
+  - name: polkadot-primitives
+    bump: none
+  - name: sp-authority-discovery 
+    bump: none
+  - name: sp-consensus-grandpa
+    bump: none
+  - name: sp-genesis-builder
+    bump: none
+  - name: sp-consensus-babe
+    bump: none
+  - name: sp-mixnet
+    bump: none
+  - name: sc-rpc-api
+    bump: none
+  - name: sp-session
+    bump: none
+  - name: sp-statement-store
+    bump: none
+  - name: sp-transaction-storage-proof
+    bump: none
+  - name: pallet-asset-rate
+    bump: none
+  - name: pallet-authorship
+    bump: none
+  - name: pallet-babe
+    bump: none
+  - name: pallet-session
+    bump: none
+  - name: pallet-timestamp
+    bump: none
+  - name: pallet-offences
+    bump: none
+  - name: pallet-staking
+    bump: none
+  - name: pallet-bags-list
+    bump: none
+  - name: pallet-broker
+    bump: none
+  - name: pallet-election-provider-multi-phase
+    bump: none
+  - name: pallet-fast-unstake
+    bump: none
+  - name: pallet-identity
+    bump: none
+  - name: pallet-transaction-payment
+    bump: none
+  - name: pallet-treasury
+    bump: none
+  - name: pallet-utility
+    bump: none
+  - name: pallet-collective
+    bump: none
+  - name: pallet-root-testing
+    bump: none
+  - name: pallet-vesting
+    bump: none
+  - name: polkadot-runtime-parachains
+    bump: none
+  - name: pallet-authority-discovery
+    bump: none
+  - name: pallet-mmr
+    bump: none
+  - name: sp-mmr-primitives
+    bump: none
+  - name: staging-xcm-executor
+    bump: none
+  - name: staging-xcm-builder
+    bump: none
+  - name: pallet-asset-conversion
+    bump: none
+  - name: pallet-assets
+    bump: none
+  - name: pallet-salary
+    bump: none
+  - name: pallet-ranked-collective
+    bump: none
+  - name: pallet-xcm
+    bump: none
+  - name: xcm-runtime-apis
+    bump: none
+  - name: pallet-grandpa
+    bump: none
+  - name: pallet-indices
+    bump: none
+  - name: pallet-sudo
+    bump: none
+  - name: sp-consensus-beefy
+    bump: none
+  - name: cumulus-primitives-storage-weight-reclaim
+    bump: none
+  - name: cumulus-pallet-aura-ext
+    bump: none
+  - name: pallet-aura
+    bump: none
+  - name: sp-consensus-aura
+    bump: none
+  - name: pallet-collator-selection
+    bump: none
+  - name: pallet-glutton
+    bump: none
+  - name: staging-parachain-info
+    bump: none
+  - name: westend-runtime
+    bump: none
+  - name: frame-metadata-hash-extension
+    bump: none
+  - name: frame-system-benchmarking
+    bump: none
+  - name: pallet-beefy
+    bump: none
+  - name: pallet-beefy-mmr
+    bump: none
+  - name: pallet-conviction-voting
+    bump: none
+  - name: pallet-scheduler
+    bump: none
+  - name: pallet-preimage
+    bump: none
+  - name: pallet-delegated-staking
+    bump: none
+  - name: pallet-nomination-pools
+    bump: none
+  - name: pallet-democracy
+    bump: none
+  - name: pallet-elections-phragmen
+    bump: none
+  - name: pallet-membership
+    bump: none
+  - name: pallet-multisig
+    bump: none
+  - name: polkadot-sdk-frame
+    bump: none
+  - name: pallet-dev-mode
+    bump: none
+  - name: pallet-verify-signature
+    bump: none
+  - name: pallet-nomination-pools-benchmarking
+    bump: none
+  - name: pallet-offences-benchmarking
+    bump: none
+  - name: pallet-im-online
+    bump: none
+  - name: pallet-parameters
+    bump: none
+  - name: pallet-proxy
+    bump: none
+  - name: pallet-recovery
+    bump: none
+  - name: pallet-referenda
+    bump: none
+  - name: pallet-society
+    bump: none
+  - name: pallet-state-trie-migration
+    bump: none
+  - name: pallet-whitelist
+    bump: none
+  - name: pallet-xcm-benchmarks
+    bump: none
+  - name: rococo-runtime
+    bump: none
+  - name: pallet-bounties
+    bump: none
+  - name: pallet-child-bounties
+    bump: none
+  - name: pallet-nis
+    bump: none
+  - name: pallet-tips
+    bump: none
+  - name: parachains-common
+    bump: none
+  - name: pallet-asset-tx-payment
+    bump: none
+  - name: cumulus-pallet-xcmp-queue
+    bump: none
+  - name: bp-xcm-bridge-hub-router
+    bump: none
+  - name: pallet-xcm-bridge-hub-router
+    bump: none
+  - name: assets-common
+    bump: none
+  - name: bp-messages
+    bump: none
+  - name: bp-parachains
+    bump: none
+  - name: bp-polkadot-core
+    bump: none
+  - name: bp-relayers
+    bump: none
+  - name: bp-xcm-bridge-hub
+    bump: none
+  - name: bridge-hub-common
+    bump: none
+  - name: snowbridge-core
+    bump: none
+  - name: snowbridge-beacon-primitives
+    bump: none
+  - name: snowbridge-ethereum
+    bump: none
+  - name: pallet-bridge-grandpa
+    bump: none
+  - name: pallet-bridge-messages
+    bump: none
+  - name: pallet-bridge-parachains
+    bump: none
+  - name: pallet-bridge-relayers
+    bump: none
+  - name: pallet-xcm-bridge-hub
+    bump: none
+  - name: cumulus-pallet-dmp-queue
+    bump: none
+  - name: cumulus-pallet-solo-to-para
+    bump: none
+  - name: cumulus-pallet-xcm
+    bump: none
+  - name: cumulus-ping
+    bump: none
+  - name: frame-benchmarking-pallet-pov
+    bump: none
+  - name: pallet-alliance
+    bump: none
+  - name: pallet-asset-conversion-ops
+    bump: none
+  - name: pallet-asset-conversion-tx-payment
+    bump: none
+  - name: pallet-assets-freezer
+    bump: none
+  - name: pallet-atomic-swap
+    bump: none
+  - name: pallet-collective-content
+    bump: none
+  - name: pallet-contracts
+    bump: none
+  - name: pallet-contracts-uapi
+    bump: none
+  - name: pallet-insecure-randomness-collective-flip
+    bump: none
+  - name: pallet-contracts-mock-network
+    bump: none
+  - name: xcm-simulator
+    bump: none
+  - name: pallet-core-fellowship
+    bump: none
+  - name: pallet-lottery
+    bump: none
+  - name: pallet-mixnet
+    bump: none
+  - name: pallet-nft-fractionalization
+    bump: none
+  - name: pallet-nfts
+    bump: none
+  - name: pallet-node-authorization
+    bump: none
+  - name: pallet-paged-list
+    bump: none
+  - name: pallet-remark
+    bump: none
+  - name: pallet-revive
+    bump: none
+  - name: pallet-revive-uapi
+    bump: none
+  - name: pallet-revive-eth-rpc
+    bump: none
+  - name: pallet-skip-feeless-payment
+    bump: none
+  - name: pallet-revive-mock-network
+    bump: none
+  - name: pallet-root-offences
+    bump: none
+  - name: pallet-safe-mode
+    bump: none
+  - name: pallet-scored-pool
+    bump: none
+  - name: pallet-statement
+    bump: none
+  - name: pallet-transaction-storage
+    bump: none
+  - name: pallet-tx-pause
+    bump: none
+  - name: pallet-uniques
+    bump: none
+  - name: snowbridge-outbound-queue-merkle-tree
+    bump: none
+  - name: snowbridge-pallet-ethereum-client
+    bump: none
+  - name: snowbridge-pallet-inbound-queue
+    bump: none
+  - name: snowbridge-router-primitives
+    bump: none
+  - name: snowbridge-pallet-outbound-queue
+    bump: none
+  - name: snowbridge-pallet-system
+    bump: none
+  - name: bp-asset-hub-rococo
+    bump: none
+  - name: bp-asset-hub-westend
+    bump: none
+  - name: bp-polkadot-bulletin
+    bump: none
+  - name: asset-hub-rococo-runtime
+    bump: none
+  - name: asset-hub-westend-runtime
+    bump: none
+  - name: bridge-hub-rococo-runtime
+    bump: none
+  - name: bridge-hub-westend-runtime
+    bump: none
+  - name: collectives-westend-runtime
+    bump: none
+  - name: coretime-rococo-runtime
+    bump: none
+  - name: coretime-westend-runtime
+    bump: none
+  - name: people-rococo-runtime
+    bump: none
+  - name: people-westend-runtime
+    bump: none
+  - name: penpal-runtime
+    bump: none
+  - name: contracts-rococo-runtime
+    bump: none
+  - name: glutton-westend-runtime
+    bump: none
+  - name: rococo-parachain-runtime
+    bump: none
+  - name: xcm-simulator-example
+    bump: none
\ No newline at end of file