FRAME: Revamp Preimage pallet to use Consideration (#1363)

Make Preimage pallet use Consideration instead of handling deposits
directly.

Other half of paritytech/substrate#13666.
Depends/based on #1361.

Script for the lazy migration that should be run manually once:
[migrate-preimage-lazy.py](https://github.com/ggwpez/substrate-scripts/blob/master/migrate-preimage-lazy.py).

## TODO

- [x] Migration code.

---------

Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>
Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>
Co-authored-by: command-bot <>
Co-authored-by: Francisco Aguirre <franciscoaguirreperez@gmail.com>
Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>

cumulus/parachains/runtimes/collectives/collectives-polkadot/src/lib.rs

@@ -67,7 +67,10 @@ use frame_support::{
 	construct_runtime,
 	dispatch::DispatchClass,
 	parameter_types,
-	traits::{ConstBool, ConstU16, ConstU32, ConstU64, ConstU8, EitherOfDiverse, InstanceFilter},
+	traits::{
+		fungible::HoldConsideration, ConstBool, ConstU16, ConstU32, ConstU64, ConstU8,
+		EitherOfDiverse, InstanceFilter, LinearStoragePrice,
+	},
 	weights::{ConstantMultiplier, Weight},
 	PalletId,
 };
@@ -209,7 +212,7 @@ impl pallet_balances::Config for Runtime {
 	type ReserveIdentifier = [u8; 8];
 	type RuntimeHoldReason = RuntimeHoldReason;
 	type FreezeIdentifier = ();
-	type MaxHolds = ConstU32<0>;
+	type MaxHolds = ConstU32<1>;
 	type MaxFreezes = ConstU32<0>;
 }
 
@@ -545,6 +548,7 @@ impl pallet_scheduler::Config for Runtime {
 parameter_types! {
 	pub const PreimageBaseDeposit: Balance = deposit(2, 64);
 	pub const PreimageByteDeposit: Balance = deposit(0, 1);
+	pub const PreimageHoldReason: RuntimeHoldReason = RuntimeHoldReason::Preimage(pallet_preimage::HoldReason::Preimage);
 }
 
 impl pallet_preimage::Config for Runtime {
@@ -552,8 +556,12 @@ impl pallet_preimage::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
 	type ManagerOrigin = EnsureRoot<AccountId>;
-	type BaseDeposit = PreimageBaseDeposit;
-	type ByteDeposit = PreimageByteDeposit;
+	type Consideration = HoldConsideration<
+		AccountId,
+		Balances,
+		PreimageHoldReason,
+		LinearStoragePrice<PreimageBaseDeposit, PreimageByteDeposit, Balance>,
+	>;
 }
 
 // Create the runtime by composing the FRAME pallets that were previously configured.
@@ -589,7 +597,7 @@ construct_runtime!(
 		Utility: pallet_utility::{Pallet, Call, Event} = 40,
 		Multisig: pallet_multisig::{Pallet, Call, Storage, Event<T>} = 41,
 		Proxy: pallet_proxy::{Pallet, Call, Storage, Event<T>} = 42,
-		Preimage: pallet_preimage::{Pallet, Call, Storage, Event<T>} = 43,
+		Preimage: pallet_preimage::{Pallet, Call, Storage, Event<T>, HoldReason} = 43,
 		Scheduler: pallet_scheduler::{Pallet, Call, Storage, Event<T>} = 44,
 
 		// The main stage.

cumulus/parachains/runtimes/collectives/collectives-polkadot/src/weights/pallet_preimage.rs

@@ -50,6 +50,21 @@ use core::marker::PhantomData;
 /// Weight functions for `pallet_preimage`.
 pub struct WeightInfo<T>(PhantomData<T>);
 impl<T: frame_system::Config> pallet_preimage::WeightInfo for WeightInfo<T> {
+	fn ensure_updated(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `193 + n * (91 ±0)`
+		//  Estimated: `3593 + n * (2566 ±0)`
+		// Minimum execution time: 2_000_000 picoseconds.
+		Weight::from_parts(2_000_000, 3593)
+			// Standard Error: 13_720
+			.saturating_add(Weight::from_parts(17_309_199, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2566).saturating_mul(n.into()))
+	}
+
 	/// Storage: `Preimage::StatusFor` (r:1 w:1)
 	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
 	/// Storage: `Preimage::PreimageFor` (r:0 w:1)

polkadot/runtime/kusama/src/lib.rs

@@ -63,8 +63,9 @@ use frame_election_provider_support::{
 use frame_support::{
 	construct_runtime, parameter_types,
 	traits::{
-		ConstU32, Contains, EitherOf, EitherOfDiverse, InstanceFilter, KeyOwnerProofSystem,
-		PrivilegeCmp, ProcessMessage, ProcessMessageError, StorageMapShim, WithdrawReasons,
+		fungible::HoldConsideration, ConstU32, Contains, EitherOf, EitherOfDiverse, InstanceFilter,
+		KeyOwnerProofSystem, LinearStoragePrice, PrivilegeCmp, ProcessMessage, ProcessMessageError,
+		StorageMapShim, WithdrawReasons,
 	},
 	weights::{ConstantMultiplier, WeightMeter},
 	PalletId,
@@ -239,6 +240,7 @@ impl pallet_scheduler::Config for Runtime {
 parameter_types! {
 	pub const PreimageBaseDeposit: Balance = deposit(2, 64);
 	pub const PreimageByteDeposit: Balance = deposit(0, 1);
+	pub const PreimageHoldReason: RuntimeHoldReason = RuntimeHoldReason::Preimage(pallet_preimage::HoldReason::Preimage);
 }
 
 impl pallet_preimage::Config for Runtime {
@@ -246,8 +248,12 @@ impl pallet_preimage::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
 	type ManagerOrigin = EnsureRoot<AccountId>;
-	type BaseDeposit = PreimageBaseDeposit;
-	type ByteDeposit = PreimageByteDeposit;
+	type Consideration = HoldConsideration<
+		AccountId,
+		Balances,
+		PreimageHoldReason,
+		LinearStoragePrice<PreimageBaseDeposit, PreimageByteDeposit, Balance>,
+	>;
 }
 
 parameter_types! {
@@ -1560,7 +1566,7 @@ construct_runtime! {
 		Multisig: pallet_multisig::{Pallet, Call, Storage, Event<T>} = 31,
 
 		// Preimage registrar.
-		Preimage: pallet_preimage::{Pallet, Call, Storage, Event<T>} = 32,
+		Preimage: pallet_preimage::{Pallet, Call, Storage, Event<T>, HoldReason} = 32,
 
 		// Bounties modules.
 		Bounties: pallet_bounties::{Pallet, Call, Storage, Event<T>} = 35,

polkadot/runtime/kusama/src/weights/pallet_preimage.rs

@@ -50,6 +50,21 @@ use core::marker::PhantomData;
 /// Weight functions for `pallet_preimage`.
 pub struct WeightInfo<T>(PhantomData<T>);
 impl<T: frame_system::Config> pallet_preimage::WeightInfo for WeightInfo<T> {
+	fn ensure_updated(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `193 + n * (91 ±0)`
+		//  Estimated: `3593 + n * (2566 ±0)`
+		// Minimum execution time: 2_000_000 picoseconds.
+		Weight::from_parts(2_000_000, 3593)
+			// Standard Error: 13_720
+			.saturating_add(Weight::from_parts(17_309_199, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2566).saturating_mul(n.into()))
+	}
+
 	/// Storage: Preimage StatusFor (r:1 w:1)
 	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
 	/// Storage: Preimage PreimageFor (r:0 w:1)

polkadot/runtime/polkadot/src/lib.rs

@@ -47,8 +47,9 @@ use frame_election_provider_support::{
 use frame_support::{
 	construct_runtime, parameter_types,
 	traits::{
-		ConstU32, Contains, EitherOf, EitherOfDiverse, InstanceFilter, KeyOwnerProofSystem,
-		PrivilegeCmp, ProcessMessage, ProcessMessageError, WithdrawReasons,
+		fungible::HoldConsideration, ConstU32, Contains, EitherOf, EitherOfDiverse, InstanceFilter,
+		KeyOwnerProofSystem, LinearStoragePrice, PrivilegeCmp, ProcessMessage, ProcessMessageError,
+		WithdrawReasons,
 	},
 	weights::{ConstantMultiplier, WeightMeter},
 	PalletId,
@@ -221,9 +222,9 @@ impl pallet_scheduler::Config for Runtime {
 }
 
 parameter_types! {
-	pub const PreimageMaxSize: u32 = 4096 * 1024;
 	pub const PreimageBaseDeposit: Balance = deposit(2, 64);
 	pub const PreimageByteDeposit: Balance = deposit(0, 1);
+	pub const PreimageHoldReason: RuntimeHoldReason = RuntimeHoldReason::Preimage(pallet_preimage::HoldReason::Preimage);
 }
 
 impl pallet_preimage::Config for Runtime {
@@ -231,8 +232,12 @@ impl pallet_preimage::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
 	type ManagerOrigin = EnsureRoot<AccountId>;
-	type BaseDeposit = PreimageBaseDeposit;
-	type ByteDeposit = PreimageByteDeposit;
+	type Consideration = HoldConsideration<
+		AccountId,
+		Balances,
+		PreimageHoldReason,
+		LinearStoragePrice<PreimageBaseDeposit, PreimageByteDeposit, Balance>,
+	>;
 }
 
 parameter_types! {
@@ -297,7 +302,7 @@ impl pallet_balances::Config for Runtime {
 	type WeightInfo = weights::pallet_balances::WeightInfo<Runtime>;
 	type RuntimeHoldReason = RuntimeHoldReason;
 	type FreezeIdentifier = ();
-	type MaxHolds = ConstU32<0>;
+	type MaxHolds = ConstU32<1>;
 	type MaxFreezes = ConstU32<0>;
 }
 
@@ -1326,7 +1331,7 @@ construct_runtime! {
 		// Basic stuff; balances is uncallable initially.
 		System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>} = 0,
 		Scheduler: pallet_scheduler::{Pallet, Call, Storage, Event<T>} = 1,
-		Preimage: pallet_preimage::{Pallet, Call, Storage, Event<T>} = 10,
+		Preimage: pallet_preimage::{Pallet, Call, Storage, Event<T>, HoldReason} = 10,
 
 		// Babe must be before session.
 		Babe: pallet_babe::{Pallet, Call, Storage, Config<T>, ValidateUnsigned} = 2,

polkadot/runtime/polkadot/src/weights/pallet_preimage.rs

@@ -50,6 +50,21 @@ use core::marker::PhantomData;
 /// Weight functions for `pallet_preimage`.
 pub struct WeightInfo<T>(PhantomData<T>);
 impl<T: frame_system::Config> pallet_preimage::WeightInfo for WeightInfo<T> {
+	fn ensure_updated(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `193 + n * (91 ±0)`
+		//  Estimated: `3593 + n * (2566 ±0)`
+		// Minimum execution time: 2_000_000 picoseconds.
+		Weight::from_parts(2_000_000, 3593)
+			// Standard Error: 13_720
+			.saturating_add(Weight::from_parts(17_309_199, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2566).saturating_mul(n.into()))
+	}
+
 	/// Storage: Preimage StatusFor (r:1 w:1)
 	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
 	/// Storage: Preimage PreimageFor (r:0 w:1)

polkadot/runtime/rococo/src/lib.rs

@@ -60,8 +60,9 @@ use beefy_primitives::{
 use frame_support::{
 	construct_runtime, parameter_types,
 	traits::{
-		Contains, EitherOfDiverse, InstanceFilter, KeyOwnerProofSystem, LockIdentifier,
-		PrivilegeCmp, ProcessMessage, ProcessMessageError, StorageMapShim, WithdrawReasons,
+		fungible::HoldConsideration, Contains, EitherOfDiverse, InstanceFilter,
+		KeyOwnerProofSystem, LinearStoragePrice, LockIdentifier, PrivilegeCmp, ProcessMessage,
+		ProcessMessageError, StorageMapShim, WithdrawReasons,
 	},
 	weights::{ConstantMultiplier, WeightMeter},
 	PalletId,
@@ -224,6 +225,7 @@ impl pallet_scheduler::Config for Runtime {
 parameter_types! {
 	pub const PreimageBaseDeposit: Balance = deposit(2, 64);
 	pub const PreimageByteDeposit: Balance = deposit(0, 1);
+	pub const PreimageHoldReason: RuntimeHoldReason = RuntimeHoldReason::Preimage(pallet_preimage::HoldReason::Preimage);
 }
 
 impl pallet_preimage::Config for Runtime {
@@ -231,8 +233,12 @@ impl pallet_preimage::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
 	type ManagerOrigin = EnsureRoot<AccountId>;
-	type BaseDeposit = PreimageBaseDeposit;
-	type ByteDeposit = PreimageByteDeposit;
+	type Consideration = HoldConsideration<
+		AccountId,
+		Balances,
+		PreimageHoldReason,
+		LinearStoragePrice<PreimageBaseDeposit, PreimageByteDeposit, Balance>,
+	>;
 }
 
 parameter_types! {
@@ -1449,7 +1455,7 @@ construct_runtime! {
 		Multisig: pallet_multisig::{Pallet, Call, Storage, Event<T>} = 31,
 
 		// Preimage registrar.
-		Preimage: pallet_preimage::{Pallet, Call, Storage, Event<T>} = 32,
+		Preimage: pallet_preimage::{Pallet, Call, Storage, Event<T>, HoldReason} = 32,
 
 		// Bounties modules.
 		Bounties: pallet_bounties::{Pallet, Call, Storage, Event<T>} = 35,

polkadot/runtime/rococo/src/weights/pallet_preimage.rs

@@ -47,6 +47,21 @@ use core::marker::PhantomData;
 /// Weight functions for `pallet_preimage`.
 pub struct WeightInfo<T>(PhantomData<T>);
 impl<T: frame_system::Config> pallet_preimage::WeightInfo for WeightInfo<T> {
+	fn ensure_updated(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `193 + n * (91 ±0)`
+		//  Estimated: `3593 + n * (2566 ±0)`
+		// Minimum execution time: 2_000_000 picoseconds.
+		Weight::from_parts(2_000_000, 3593)
+			// Standard Error: 13_720
+			.saturating_add(Weight::from_parts(17_309_199, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2566).saturating_mul(n.into()))
+	}
+
 	/// Storage: Preimage StatusFor (r:1 w:1)
 	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
 	/// Storage: Preimage PreimageFor (r:0 w:1)

polkadot/runtime/westend/src/lib.rs

@@ -29,8 +29,8 @@ use frame_election_provider_support::{bounds::ElectionBoundsBuilder, onchain, Se
 use frame_support::{
 	construct_runtime, parameter_types,
 	traits::{
-		ConstU32, InstanceFilter, KeyOwnerProofSystem, ProcessMessage, ProcessMessageError,
-		WithdrawReasons,
+		fungible::HoldConsideration, ConstU32, InstanceFilter, KeyOwnerProofSystem,
+		LinearStoragePrice, ProcessMessage, ProcessMessageError, WithdrawReasons,
 	},
 	weights::{ConstantMultiplier, WeightMeter},
 	PalletId,
@@ -193,9 +193,9 @@ impl pallet_scheduler::Config for Runtime {
 }
 
 parameter_types! {
-	pub const PreimageMaxSize: u32 = 4096 * 1024;
 	pub const PreimageBaseDeposit: Balance = deposit(2, 64);
 	pub const PreimageByteDeposit: Balance = deposit(0, 1);
+	pub const PreimageHoldReason: RuntimeHoldReason = RuntimeHoldReason::Preimage(pallet_preimage::HoldReason::Preimage);
 }
 
 impl pallet_preimage::Config for Runtime {
@@ -203,8 +203,12 @@ impl pallet_preimage::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
 	type ManagerOrigin = EnsureRoot<AccountId>;
-	type BaseDeposit = PreimageBaseDeposit;
-	type ByteDeposit = PreimageByteDeposit;
+	type Consideration = HoldConsideration<
+		AccountId,
+		Balances,
+		PreimageHoldReason,
+		LinearStoragePrice<PreimageBaseDeposit, PreimageByteDeposit, Balance>,
+	>;
 }
 
 parameter_types! {
@@ -268,7 +272,7 @@ impl pallet_balances::Config for Runtime {
 	type WeightInfo = weights::pallet_balances::WeightInfo<Runtime>;
 	type RuntimeHoldReason = RuntimeHoldReason;
 	type FreezeIdentifier = ();
-	type MaxHolds = ConstU32<0>;
+	type MaxHolds = ConstU32<1>;
 	type MaxFreezes = ConstU32<0>;
 }
 
@@ -1311,7 +1315,7 @@ construct_runtime! {
 		Scheduler: pallet_scheduler::{Pallet, Call, Storage, Event<T>} = 20,
 
 		// Preimage registrar.
-		Preimage: pallet_preimage::{Pallet, Call, Storage, Event<T>} = 28,
+		Preimage: pallet_preimage::{Pallet, Call, Storage, Event<T>, HoldReason} = 28,
 
 		// Sudo.
 		Sudo: pallet_sudo::{Pallet, Call, Storage, Event<T>, Config<T>} = 21,

polkadot/runtime/westend/src/weights/pallet_preimage.rs

@@ -50,6 +50,21 @@ use core::marker::PhantomData;
 /// Weight functions for `pallet_preimage`.
 pub struct WeightInfo<T>(PhantomData<T>);
 impl<T: frame_system::Config> pallet_preimage::WeightInfo for WeightInfo<T> {
+	fn ensure_updated(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `193 + n * (91 ±0)`
+		//  Estimated: `3593 + n * (2566 ±0)`
+		// Minimum execution time: 2_000_000 picoseconds.
+		Weight::from_parts(2_000_000, 3593)
+			// Standard Error: 13_720
+			.saturating_add(Weight::from_parts(17_309_199, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2566).saturating_mul(n.into()))
+	}
+
 	/// Storage: Preimage StatusFor (r:1 w:1)
 	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
 	/// Storage: Preimage PreimageFor (r:0 w:1)

substrate/bin/node/runtime/src/lib.rs

@@ -35,11 +35,12 @@ use frame_support::{
 	pallet_prelude::Get,
 	parameter_types,
 	traits::{
-		fungible::{Balanced, Credit, ItemOf},
+		fungible::{Balanced, Credit, HoldConsideration, ItemOf},
 		tokens::{nonfungibles_v2::Inspect, GetSalary, PayFromAccount},
 		AsEnsureOriginWithArg, ConstBool, ConstU128, ConstU16, ConstU32, Contains, Currency,
 		EitherOfDiverse, EqualPrivilegeOnly, Imbalance, InsideBoth, InstanceFilter,
-		KeyOwnerProofSystem, LockIdentifier, Nothing, OnUnbalanced, WithdrawReasons,
+		KeyOwnerProofSystem, LinearStoragePrice, LockIdentifier, Nothing, OnUnbalanced,
+		WithdrawReasons,
 	},
 	weights::{
 		constants::{
@@ -447,10 +448,10 @@ impl pallet_glutton::Config for Runtime {
 }
 
 parameter_types! {
-	pub const PreimageMaxSize: u32 = 4096 * 1024;
 	pub const PreimageBaseDeposit: Balance = 1 * DOLLARS;
 	// One cent: $10,000 / MB
 	pub const PreimageByteDeposit: Balance = 1 * CENTS;
+	pub const PreimageHoldReason: RuntimeHoldReason = RuntimeHoldReason::Preimage(pallet_preimage::HoldReason::Preimage);
 }
 
 impl pallet_preimage::Config for Runtime {
@@ -458,8 +459,12 @@ impl pallet_preimage::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
 	type ManagerOrigin = EnsureRoot<AccountId>;
-	type BaseDeposit = PreimageBaseDeposit;
-	type ByteDeposit = PreimageByteDeposit;
+	type Consideration = HoldConsideration<
+		AccountId,
+		Balances,
+		PreimageHoldReason,
+		LinearStoragePrice<PreimageBaseDeposit, PreimageByteDeposit, Balance>,
+	>;
 }
 
 parameter_types! {

substrate/frame/balances/src/tests/currency_tests.rs

@@ -22,7 +22,7 @@ use crate::NegativeImbalance;
 use frame_support::traits::{
 	BalanceStatus::{Free, Reserved},
 	Currency,
-	ExistenceRequirement::{self, AllowDeath},
+	ExistenceRequirement::{self, AllowDeath, KeepAlive},
 	Hooks, LockIdentifier, LockableCurrency, NamedReservableCurrency, ReservableCurrency,
 	WithdrawReasons,
 };
@@ -33,6 +33,18 @@ const ID_2: LockIdentifier = *b"2       ";
 pub const CALL: &<Test as frame_system::Config>::RuntimeCall =
 	&RuntimeCall::Balances(crate::Call::transfer_allow_death { dest: 0, value: 0 });
 
+#[test]
+fn ed_should_work() {
+	ExtBuilder::default().existential_deposit(1).build_and_execute_with(|| {
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), 1, 1000));
+		assert_noop!(
+			<Balances as Currency<_>>::transfer(&1, &10, 1000, KeepAlive),
+			TokenError::NotExpendable
+		);
+		assert_ok!(<Balances as Currency<_>>::transfer(&1, &10, 1000, AllowDeath));
+	});
+}
+
 #[test]
 fn set_lock_with_amount_zero_removes_lock() {
 	ExtBuilder::default()

substrate/frame/democracy/src/tests.rs

@@ -111,8 +111,7 @@ impl pallet_preimage::Config for Test {
 	type WeightInfo = ();
 	type Currency = Balances;
 	type ManagerOrigin = EnsureRoot<u64>;
-	type BaseDeposit = ConstU64<0>;
-	type ByteDeposit = ConstU64<0>;
+	type Consideration = ();
 }
 
 impl pallet_scheduler::Config for Test {

substrate/frame/preimage/src/benchmarking.rs

@@ -18,7 +18,7 @@
 //! Preimage pallet benchmarking.
 
 use super::*;
-use frame_benchmarking::v1::{account, benchmarks, whitelist_account, BenchmarkError};
+use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller, BenchmarkError};
 use frame_support::assert_ok;
 use frame_system::RawOrigin;
 use sp_runtime::traits::Bounded;
@@ -26,11 +26,9 @@ use sp_std::{prelude::*, vec};
 
 use crate::Pallet as Preimage;
 
-const SEED: u32 = 0;
-
-fn funded_account<T: Config>(name: &'static str, index: u32) -> T::AccountId {
-	let caller: T::AccountId = account(name, index, SEED);
-	T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+fn funded_account<T: Config>() -> T::AccountId {
+	let caller: T::AccountId = whitelisted_caller();
+	T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value() / 2u32.into());
 	caller
 }
 
@@ -49,8 +47,7 @@ benchmarks! {
 	// Expensive note - will reserve.
 	note_preimage {
 		let s in 0 .. MAX_SIZE;
-		let caller = funded_account::<T>("caller", 0);
-		whitelist_account!(caller);
+		let caller = funded_account::<T>();
 		let (preimage, hash) = sized_preimage_and_hash::<T>(s);
 	}: _(RawOrigin::Signed(caller), preimage)
 	verify {
@@ -59,8 +56,7 @@ benchmarks! {
 	// Cheap note - will not reserve since it was requested.
 	note_requested_preimage {
 		let s in 0 .. MAX_SIZE;
-		let caller = funded_account::<T>("caller", 0);
-		whitelist_account!(caller);
+		let caller = funded_account::<T>();
 		let (preimage, hash) = sized_preimage_and_hash::<T>(s);
 		assert_ok!(Preimage::<T>::request_preimage(
 			T::ManagerOrigin::try_successful_origin()
@@ -89,8 +85,7 @@ benchmarks! {
 
 	// Expensive unnote - will unreserve.
 	unnote_preimage {
-		let caller = funded_account::<T>("caller", 0);
-		whitelist_account!(caller);
+		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)
@@ -115,16 +110,15 @@ benchmarks! {
 	// Expensive request - will unreserve the noter's deposit.
 	request_preimage {
 		let (preimage, hash) = preimage_and_hash::<T>();
-		let noter = funded_account::<T>("noter", 0);
-		whitelist_account!(noter);
+		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 deposit = T::BaseDeposit::get() + T::ByteDeposit::get() * MAX_SIZE.into();
-		let s = RequestStatus::Requested { deposit: Some((noter, deposit)), count: 1, len: Some(MAX_SIZE) };
-		assert_eq!(StatusFor::<T>::get(&hash), Some(s));
+		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 {
@@ -138,8 +132,8 @@ benchmarks! {
 		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
 		hash
 	) verify {
-		let s = RequestStatus::Requested { deposit: None, count: 2, len: Some(MAX_SIZE) };
-		assert_eq!(StatusFor::<T>::get(&hash), Some(s));
+		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 {
@@ -148,8 +142,8 @@ benchmarks! {
 		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
 		hash
 	) verify {
-		let s = RequestStatus::Requested { deposit: None, count: 1, len: None };
-		assert_eq!(StatusFor::<T>::get(&hash), Some(s));
+		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 {
@@ -163,8 +157,8 @@ benchmarks! {
 		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
 		hash
 	) verify {
-		let s = RequestStatus::Requested { deposit: None, count: 2, len: None };
-		assert_eq!(StatusFor::<T>::get(&hash), Some(s));
+		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.
@@ -184,7 +178,7 @@ benchmarks! {
 		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
 		hash
 	) verify {
-		assert_eq!(StatusFor::<T>::get(&hash), None);
+		assert_eq!(RequestStatusFor::<T>::get(&hash), None);
 	}
 	// Cheap unrequest - last reference, but it's not noted.
 	unrequest_unnoted_preimage {
@@ -198,7 +192,7 @@ benchmarks! {
 		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
 		hash
 	) verify {
-		assert_eq!(StatusFor::<T>::get(&hash), None);
+		assert_eq!(RequestStatusFor::<T>::get(&hash), None);
 	}
 	// Cheap unrequest - not the last reference.
 	unrequest_multi_referenced_preimage {
@@ -217,9 +211,38 @@ benchmarks! {
 		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
 		hash
 	) verify {
-		let s = RequestStatus::Requested { deposit: None, count: 1, len: None };
-		assert_eq!(StatusFor::<T>::get(&hash), Some(s));
+		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 0..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 {
+		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
+}

substrate/frame/preimage/src/lib.rs

@@ -37,7 +37,10 @@ mod mock;
 mod tests;
 pub mod weights;
 
-use sp_runtime::traits::{BadOrigin, Hash, Saturating};
+use sp_runtime::{
+	traits::{BadOrigin, Hash, Saturating},
+	Perbill,
+};
 use sp_std::{borrow::Cow, prelude::*};
 
 use codec::{Decode, Encode, MaxEncodedLen};
@@ -46,8 +49,8 @@ use frame_support::{
 	ensure,
 	pallet_prelude::Get,
 	traits::{
-		Currency, Defensive, FetchResult, Hash as PreimageHash, PreimageProvider,
-		PreimageRecipient, QueryPreimage, ReservableCurrency, StorePreimage,
+		Consideration, Currency, Defensive, FetchResult, Footprint, Hash as PreimageHash,
+		PreimageProvider, PreimageRecipient, QueryPreimage, ReservableCurrency, StorePreimage,
 	},
 	BoundedSlice, BoundedVec,
 };
@@ -61,7 +64,7 @@ pub use pallet::*;
 
 /// A type to note whether a preimage is owned by a user or the system.
 #[derive(Clone, Eq, PartialEq, Encode, Decode, TypeInfo, MaxEncodedLen, RuntimeDebug)]
-pub enum RequestStatus<AccountId, Balance> {
+pub enum OldRequestStatus<AccountId, Balance> {
 	/// The associated preimage has not yet been requested by the system. The given deposit (if
 	/// some) is being held until either it becomes requested or the user retracts the preimage.
 	Unrequested { deposit: (AccountId, Balance), len: u32 },
@@ -71,13 +74,31 @@ pub enum RequestStatus<AccountId, Balance> {
 	Requested { deposit: Option<(AccountId, Balance)>, count: u32, len: Option<u32> },
 }
 
+/// A type to note whether a preimage is owned by a user or the system.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, TypeInfo, MaxEncodedLen, RuntimeDebug)]
+pub enum RequestStatus<AccountId, Ticket> {
+	/// The associated preimage has not yet been requested by the system. The given deposit (if
+	/// some) is being held until either it becomes requested or the user retracts the preimage.
+	Unrequested { ticket: (AccountId, Ticket), len: u32 },
+	/// There are a non-zero number of outstanding requests for this hash by this chain. If there
+	/// is a preimage registered, then `len` is `Some` and it may be removed iff this counter
+	/// becomes zero.
+	Requested { maybe_ticket: Option<(AccountId, Ticket)>, count: u32, maybe_len: Option<u32> },
+}
+
 type BalanceOf<T> =
 	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+type TicketOf<T> = <T as Config>::Consideration;
 
 /// Maximum size of preimage we can store is 4mb.
 const MAX_SIZE: u32 = 4 * 1024 * 1024;
+/// Hard-limit on the number of hashes that can be passed to `ensure_updated`.
+///
+/// Exists only for benchmarking purposes.
+pub const MAX_HASH_UPGRADE_BULK_COUNT: u32 = 1024;
 
 #[frame_support::pallet]
+#[allow(deprecated)]
 pub mod pallet {
 	use super::*;
 
@@ -93,17 +114,15 @@ pub mod pallet {
 		type WeightInfo: weights::WeightInfo;
 
 		/// Currency type for this pallet.
+		// TODO#1569: Remove.
 		type Currency: ReservableCurrency<Self::AccountId>;
 
 		/// An origin that can request a preimage be placed on-chain without a deposit or fee, or
 		/// manage existing preimages.
 		type ManagerOrigin: EnsureOrigin<Self::RuntimeOrigin>;
 
-		/// The base deposit for placing a preimage on chain.
-		type BaseDeposit: Get<BalanceOf<Self>>;
-
-		/// The per-byte deposit for placing a preimage on chain.
-		type ByteDeposit: Get<BalanceOf<Self>>;
+		/// A means of providing some cost while data is stored on-chain.
+		type Consideration: Consideration<Self::AccountId>;
 	}
 
 	#[pallet::pallet]
@@ -135,18 +154,33 @@ pub mod pallet {
 		Requested,
 		/// The preimage request cannot be removed since no outstanding requests exist.
 		NotRequested,
+		/// More than `MAX_HASH_UPGRADE_BULK_COUNT` hashes were requested to be upgraded at once.
+		TooMany,
+	}
+
+	/// A reason for this pallet placing a hold on funds.
+	#[pallet::composite_enum]
+	pub enum HoldReason {
+		/// The funds are held as storage deposit for a preimage.
+		Preimage,
 	}
 
 	/// The request status of a given hash.
+	#[deprecated = "RequestStatusFor"]
 	#[pallet::storage]
 	pub(super) type StatusFor<T: Config> =
-		StorageMap<_, Identity, T::Hash, RequestStatus<T::AccountId, BalanceOf<T>>>;
+		StorageMap<_, Identity, T::Hash, OldRequestStatus<T::AccountId, BalanceOf<T>>>;
+
+	/// The request status of a given hash.
+	#[pallet::storage]
+	pub(super) type RequestStatusFor<T: Config> =
+		StorageMap<_, Identity, T::Hash, RequestStatus<T::AccountId, TicketOf<T>>>;
 
 	#[pallet::storage]
 	pub(super) type PreimageFor<T: Config> =
 		StorageMap<_, Identity, (T::Hash, u32), BoundedVec<u8, ConstU32<MAX_SIZE>>>;
 
-	#[pallet::call]
+	#[pallet::call(weight = T::WeightInfo)]
 	impl<T: Config> Pallet<T> {
 		/// Register a preimage on-chain.
 		///
@@ -173,7 +207,6 @@ pub mod pallet {
 		/// - `hash`: The hash of the preimage to be removed from the store.
 		/// - `len`: The length of the preimage of `hash`.
 		#[pallet::call_index(1)]
-		#[pallet::weight(T::WeightInfo::unnote_preimage())]
 		pub fn unnote_preimage(origin: OriginFor<T>, hash: T::Hash) -> DispatchResult {
 			let maybe_sender = Self::ensure_signed_or_manager(origin)?;
 			Self::do_unnote_preimage(&hash, maybe_sender)
@@ -184,7 +217,6 @@ pub mod pallet {
 		/// If the preimage requests has already been provided on-chain, we unreserve any deposit
 		/// a user may have paid, and take the control of the preimage out of their hands.
 		#[pallet::call_index(2)]
-		#[pallet::weight(T::WeightInfo::request_preimage())]
 		pub fn request_preimage(origin: OriginFor<T>, hash: T::Hash) -> DispatchResult {
 			T::ManagerOrigin::ensure_origin(origin)?;
 			Self::do_request_preimage(&hash);
@@ -195,15 +227,80 @@ pub mod pallet {
 		///
 		/// NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`.
 		#[pallet::call_index(3)]
-		#[pallet::weight(T::WeightInfo::unrequest_preimage())]
 		pub fn unrequest_preimage(origin: OriginFor<T>, hash: T::Hash) -> DispatchResult {
 			T::ManagerOrigin::ensure_origin(origin)?;
 			Self::do_unrequest_preimage(&hash)
 		}
+
+		/// Ensure that the a bulk of pre-images is upgraded.
+		///
+		/// The caller pays no fee if at least 90% of pre-images were successfully updated.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::ensure_updated(hashes.len() as u32))]
+		pub fn ensure_updated(
+			origin: OriginFor<T>,
+			hashes: Vec<T::Hash>,
+		) -> DispatchResultWithPostInfo {
+			ensure_signed(origin)?;
+			ensure!(hashes.len() <= MAX_HASH_UPGRADE_BULK_COUNT as usize, Error::<T>::TooMany);
+
+			let updated = hashes.iter().map(Self::do_ensure_updated).filter(|b| *b).count() as u32;
+			let ratio = Perbill::from_rational(updated, hashes.len() as u32);
+
+			let pays: Pays = (ratio < Perbill::from_percent(90)).into();
+			Ok(pays.into())
+		}
 	}
 }
 
 impl<T: Config> Pallet<T> {
+	fn do_ensure_updated(h: &T::Hash) -> bool {
+		#[allow(deprecated)]
+		let r = match StatusFor::<T>::take(h) {
+			Some(r) => r,
+			None => return false,
+		};
+		let n = match r {
+			OldRequestStatus::Unrequested { deposit: (who, amount), len } => {
+				// unreserve deposit
+				T::Currency::unreserve(&who, amount);
+				// take consideration
+				let Ok(ticket) =
+					T::Consideration::new(&who, Footprint::from_parts(1, len as usize))
+						.defensive_proof("Unexpected inability to take deposit after unreserved")
+				else {
+					return true
+				};
+				RequestStatus::Unrequested { ticket: (who, ticket), len }
+			},
+			OldRequestStatus::Requested { deposit: maybe_deposit, count, len: maybe_len } => {
+				let maybe_ticket = if let Some((who, deposit)) = maybe_deposit {
+					// unreserve deposit
+					T::Currency::unreserve(&who, deposit);
+					// take consideration
+					if let Some(len) = maybe_len {
+						let Ok(ticket) =
+							T::Consideration::new(&who, Footprint::from_parts(1, len as usize))
+								.defensive_proof(
+									"Unexpected inability to take deposit after unreserved",
+								)
+						else {
+							return true
+						};
+						Some((who, ticket))
+					} else {
+						None
+					}
+				} else {
+					None
+				};
+				RequestStatus::Requested { maybe_ticket, count, maybe_len }
+			},
+		};
+		RequestStatusFor::<T>::insert(h, n);
+		true
+	}
+
 	/// Ensure that the origin is either the `ManagerOrigin` or a signed origin.
 	fn ensure_signed_or_manager(
 		origin: T::RuntimeOrigin,
@@ -230,26 +327,29 @@ impl<T: Config> Pallet<T> {
 		let len = preimage.len() as u32;
 		ensure!(len <= MAX_SIZE, Error::<T>::TooBig);
 
+		Self::do_ensure_updated(&hash);
 		// We take a deposit only if there is a provided depositor and the preimage was not
 		// previously requested. This also allows the tx to pay no fee.
-		let status = match (StatusFor::<T>::get(hash), maybe_depositor) {
-			(Some(RequestStatus::Requested { count, deposit, .. }), _) =>
-				RequestStatus::Requested { count, deposit, len: Some(len) },
+		let status = match (RequestStatusFor::<T>::get(hash), maybe_depositor) {
+			(Some(RequestStatus::Requested { maybe_ticket, count, .. }), _) =>
+				RequestStatus::Requested { maybe_ticket, count, maybe_len: Some(len) },
 			(Some(RequestStatus::Unrequested { .. }), Some(_)) =>
 				return Err(Error::<T>::AlreadyNoted.into()),
-			(Some(RequestStatus::Unrequested { len, deposit }), None) =>
-				RequestStatus::Requested { deposit: Some(deposit), count: 1, len: Some(len) },
-			(None, None) => RequestStatus::Requested { count: 1, len: Some(len), deposit: None },
+			(Some(RequestStatus::Unrequested { ticket, len }), None) => RequestStatus::Requested {
+				maybe_ticket: Some(ticket),
+				count: 1,
+				maybe_len: Some(len),
+			},
+			(None, None) =>
+				RequestStatus::Requested { maybe_ticket: None, count: 1, maybe_len: Some(len) },
 			(None, Some(depositor)) => {
-				let length = preimage.len() as u32;
-				let deposit = T::BaseDeposit::get()
-					.saturating_add(T::ByteDeposit::get().saturating_mul(length.into()));
-				T::Currency::reserve(depositor, deposit)?;
-				RequestStatus::Unrequested { deposit: (depositor.clone(), deposit), len }
+				let ticket =
+					T::Consideration::new(depositor, Footprint::from_parts(1, len as usize))?;
+				RequestStatus::Unrequested { ticket: (depositor.clone(), ticket), len }
 			},
 		};
 		let was_requested = matches!(status, RequestStatus::Requested { .. });
-		StatusFor::<T>::insert(hash, status);
+		RequestStatusFor::<T>::insert(hash, status);
 
 		let _ = Self::insert(&hash, preimage)
 			.defensive_proof("Unable to insert. Logic error in `note_bytes`?");
@@ -264,15 +364,19 @@ impl<T: Config> Pallet<T> {
 	// If the preimage already exists before the request is made, the deposit for the preimage is
 	// returned to the user, and removed from their management.
 	fn do_request_preimage(hash: &T::Hash) {
-		let (count, len, deposit) =
-			StatusFor::<T>::get(hash).map_or((1, None, None), |x| match x {
-				RequestStatus::Requested { mut count, len, deposit } => {
+		Self::do_ensure_updated(&hash);
+		let (count, maybe_len, maybe_ticket) =
+			RequestStatusFor::<T>::get(hash).map_or((1, None, None), |x| match x {
+				RequestStatus::Requested { maybe_ticket, mut count, maybe_len } => {
 					count.saturating_inc();
-					(count, len, deposit)
+					(count, maybe_len, maybe_ticket)
 				},
-				RequestStatus::Unrequested { deposit, len } => (1, Some(len), Some(deposit)),
+				RequestStatus::Unrequested { ticket, len } => (1, Some(len), Some(ticket)),
 			});
-		StatusFor::<T>::insert(hash, RequestStatus::Requested { count, len, deposit });
+		RequestStatusFor::<T>::insert(
+			hash,
+			RequestStatus::Requested { maybe_ticket, count, maybe_len },
+		);
 		if count == 1 {
 			Self::deposit_event(Event::Requested { hash: *hash });
 		}
@@ -288,24 +392,25 @@ impl<T: Config> Pallet<T> {
 		hash: &T::Hash,
 		maybe_check_owner: Option<T::AccountId>,
 	) -> DispatchResult {
-		match StatusFor::<T>::get(hash).ok_or(Error::<T>::NotNoted)? {
-			RequestStatus::Requested { deposit: Some((owner, deposit)), count, len } => {
+		Self::do_ensure_updated(&hash);
+		match RequestStatusFor::<T>::get(hash).ok_or(Error::<T>::NotNoted)? {
+			RequestStatus::Requested { maybe_ticket: Some((owner, ticket)), count, maybe_len } => {
 				ensure!(maybe_check_owner.map_or(true, |c| c == owner), Error::<T>::NotAuthorized);
-				T::Currency::unreserve(&owner, deposit);
-				StatusFor::<T>::insert(
+				let _ = ticket.drop(&owner);
+				RequestStatusFor::<T>::insert(
 					hash,
-					RequestStatus::Requested { deposit: None, count, len },
+					RequestStatus::Requested { maybe_ticket: None, count, maybe_len },
 				);
 				Ok(())
 			},
-			RequestStatus::Requested { deposit: None, .. } => {
+			RequestStatus::Requested { maybe_ticket: None, .. } => {
 				ensure!(maybe_check_owner.is_none(), Error::<T>::NotAuthorized);
 				Self::do_unrequest_preimage(hash)
 			},
-			RequestStatus::Unrequested { deposit: (owner, deposit), len } => {
+			RequestStatus::Unrequested { ticket: (owner, ticket), len } => {
 				ensure!(maybe_check_owner.map_or(true, |c| c == owner), Error::<T>::NotAuthorized);
-				T::Currency::unreserve(&owner, deposit);
-				StatusFor::<T>::remove(hash);
+				let _ = ticket.drop(&owner);
+				RequestStatusFor::<T>::remove(hash);
 
 				Self::remove(hash, len);
 				Self::deposit_event(Event::Cleared { hash: *hash });
@@ -316,25 +421,32 @@ impl<T: Config> Pallet<T> {
 
 	/// Clear a preimage request.
 	fn do_unrequest_preimage(hash: &T::Hash) -> DispatchResult {
-		match StatusFor::<T>::get(hash).ok_or(Error::<T>::NotRequested)? {
-			RequestStatus::Requested { mut count, len, deposit } if count > 1 => {
+		Self::do_ensure_updated(&hash);
+		match RequestStatusFor::<T>::get(hash).ok_or(Error::<T>::NotRequested)? {
+			RequestStatus::Requested { mut count, maybe_len, maybe_ticket } if count > 1 => {
 				count.saturating_dec();
-				StatusFor::<T>::insert(hash, RequestStatus::Requested { count, len, deposit });
+				RequestStatusFor::<T>::insert(
+					hash,
+					RequestStatus::Requested { maybe_ticket, count, maybe_len },
+				);
 			},
-			RequestStatus::Requested { count, len, deposit } => {
+			RequestStatus::Requested { count, maybe_len, maybe_ticket } => {
 				debug_assert!(count == 1, "preimage request counter at zero?");
-				match (len, deposit) {
+				match (maybe_len, maybe_ticket) {
 					// Preimage was never noted.
-					(None, _) => StatusFor::<T>::remove(hash),
+					(None, _) => RequestStatusFor::<T>::remove(hash),
 					// Preimage was noted without owner - just remove it.
 					(Some(len), None) => {
 						Self::remove(hash, len);
-						StatusFor::<T>::remove(hash);
+						RequestStatusFor::<T>::remove(hash);
 						Self::deposit_event(Event::Cleared { hash: *hash });
 					},
 					// Preimage was noted with owner - move to unrequested so they can get refund.
-					(Some(len), Some(deposit)) => {
-						StatusFor::<T>::insert(hash, RequestStatus::Unrequested { deposit, len });
+					(Some(len), Some(ticket)) => {
+						RequestStatusFor::<T>::insert(
+							hash,
+							RequestStatus::Unrequested { ticket, len },
+						);
 					},
 				}
 			},
@@ -359,8 +471,10 @@ impl<T: Config> Pallet<T> {
 
 	fn len(hash: &T::Hash) -> Option<u32> {
 		use RequestStatus::*;
-		match StatusFor::<T>::get(hash) {
-			Some(Requested { len: Some(len), .. }) | Some(Unrequested { len, .. }) => Some(len),
+		Self::do_ensure_updated(&hash);
+		match RequestStatusFor::<T>::get(hash) {
+			Some(Requested { maybe_len: Some(len), .. }) | Some(Unrequested { len, .. }) =>
+				Some(len),
 			_ => None,
 		}
 	}
@@ -380,7 +494,8 @@ impl<T: Config> PreimageProvider<T::Hash> for Pallet<T> {
 	}
 
 	fn preimage_requested(hash: &T::Hash) -> bool {
-		matches!(StatusFor::<T>::get(hash), Some(RequestStatus::Requested { .. }))
+		Self::do_ensure_updated(hash);
+		matches!(RequestStatusFor::<T>::get(hash), Some(RequestStatus::Requested { .. }))
 	}
 
 	fn get_preimage(hash: &T::Hash) -> Option<Vec<u8>> {
@@ -423,7 +538,8 @@ impl<T: Config<Hash = PreimageHash>> QueryPreimage for Pallet<T> {
 	}
 
 	fn is_requested(hash: &T::Hash) -> bool {
-		matches!(StatusFor::<T>::get(hash), Some(RequestStatus::Requested { .. }))
+		Self::do_ensure_updated(&hash);
+		matches!(RequestStatusFor::<T>::get(hash), Some(RequestStatus::Requested { .. }))
 	}
 
 	fn request(hash: &T::Hash) {

substrate/frame/preimage/src/migration.rs

@@ -37,7 +37,7 @@ mod v0 {
 	use super::*;
 
 	#[derive(Clone, Eq, PartialEq, Encode, Decode, TypeInfo, MaxEncodedLen, RuntimeDebug)]
-	pub enum RequestStatus<AccountId, Balance> {
+	pub enum OldRequestStatus<AccountId, Balance> {
 		Unrequested(Option<(AccountId, Balance)>),
 		Requested(u32),
 	}
@@ -55,7 +55,7 @@ mod v0 {
 		Pallet<T>,
 		Identity,
 		<T as frame_system::Config>::Hash,
-		RequestStatus<<T as frame_system::Config>::AccountId, BalanceOf<T>>,
+		OldRequestStatus<<T as frame_system::Config>::AccountId, BalanceOf<T>>,
 	>;
 
 	/// Returns the number of images or `None` if the storage is corrupted.
@@ -127,21 +127,22 @@ pub mod v1 {
 				}
 
 				let status = match status {
-					v0::RequestStatus::Unrequested(deposit) => match deposit {
-						Some(deposit) => RequestStatus::Unrequested { deposit, len },
+					v0::OldRequestStatus::Unrequested(deposit) => match deposit {
+						Some(deposit) => OldRequestStatus::Unrequested { deposit, len },
 						// `None` depositor becomes system-requested.
 						None =>
-							RequestStatus::Requested { deposit: None, count: 1, len: Some(len) },
+							OldRequestStatus::Requested { deposit: None, count: 1, len: Some(len) },
 					},
-					v0::RequestStatus::Requested(count) if count == 0 => {
+					v0::OldRequestStatus::Requested(count) if count == 0 => {
 						log::error!(target: TARGET, "preimage has counter of zero: {:?}", hash);
 						continue
 					},
-					v0::RequestStatus::Requested(count) =>
-						RequestStatus::Requested { deposit: None, count, len: Some(len) },
+					v0::OldRequestStatus::Requested(count) =>
+						OldRequestStatus::Requested { deposit: None, count, len: Some(len) },
 				};
 				log::trace!(target: TARGET, "Moving preimage {:?} with len {}", hash, len);
 
+				#[allow(deprecated)]
 				crate::StatusFor::<T>::insert(hash, status);
 				crate::PreimageFor::<T>::insert(&(hash, len), preimage);
 
@@ -176,6 +177,7 @@ pub mod v1 {
 	pub fn image_count<T: Config>() -> Option<u32> {
 		// Use iter_values() to ensure that the values are decodable.
 		let images = crate::PreimageFor::<T>::iter_values().count() as u32;
+		#[allow(deprecated)]
 		let status = crate::StatusFor::<T>::iter_values().count() as u32;
 
 		if images == status {
@@ -189,6 +191,7 @@ pub mod v1 {
 #[cfg(test)]
 #[cfg(feature = "try-runtime")]
 mod test {
+	#![allow(deprecated)]
 	use super::*;
 	use crate::mock::{Test as T, *};
 
@@ -203,19 +206,19 @@ mod test {
 			// Case 1: Unrequested without deposit
 			let (p, h) = preimage::<T>(128);
 			v0::PreimageFor::<T>::insert(h, p);
-			v0::StatusFor::<T>::insert(h, v0::RequestStatus::Unrequested(None));
+			v0::StatusFor::<T>::insert(h, v0::OldRequestStatus::Unrequested(None));
 			// Case 2: Unrequested with deposit
 			let (p, h) = preimage::<T>(1024);
 			v0::PreimageFor::<T>::insert(h, p);
-			v0::StatusFor::<T>::insert(h, v0::RequestStatus::Unrequested(Some((1, 1))));
+			v0::StatusFor::<T>::insert(h, v0::OldRequestStatus::Unrequested(Some((1, 1))));
 			// Case 3: Requested by 0 (invalid)
 			let (p, h) = preimage::<T>(8192);
 			v0::PreimageFor::<T>::insert(h, p);
-			v0::StatusFor::<T>::insert(h, v0::RequestStatus::Requested(0));
+			v0::StatusFor::<T>::insert(h, v0::OldRequestStatus::Requested(0));
 			// Case 4: Requested by 10
 			let (p, h) = preimage::<T>(65536);
 			v0::PreimageFor::<T>::insert(h, p);
-			v0::StatusFor::<T>::insert(h, v0::RequestStatus::Requested(10));
+			v0::StatusFor::<T>::insert(h, v0::OldRequestStatus::Requested(10));
 
 			assert_eq!(v0::image_count::<T>(), Some(4));
 			assert_eq!(v1::image_count::<T>(), None, "V1 storage should be corrupted");
@@ -234,14 +237,14 @@ mod test {
 			assert_eq!(crate::PreimageFor::<T>::get(&(h, 128)), Some(p));
 			assert_eq!(
 				crate::StatusFor::<T>::get(h),
-				Some(RequestStatus::Requested { deposit: None, count: 1, len: Some(128) })
+				Some(OldRequestStatus::Requested { deposit: None, count: 1, len: Some(128) })
 			);
 			// Case 2: Unrequested with deposit becomes unrequested
 			let (p, h) = preimage::<T>(1024);
 			assert_eq!(crate::PreimageFor::<T>::get(&(h, 1024)), Some(p));
 			assert_eq!(
 				crate::StatusFor::<T>::get(h),
-				Some(RequestStatus::Unrequested { deposit: (1, 1), len: 1024 })
+				Some(OldRequestStatus::Unrequested { deposit: (1, 1), len: 1024 })
 			);
 			// Case 3: Requested by 0 should be skipped
 			let (_, h) = preimage::<T>(8192);
@@ -252,7 +255,7 @@ mod test {
 			assert_eq!(crate::PreimageFor::<T>::get(&(h, 65536)), Some(p));
 			assert_eq!(
 				crate::StatusFor::<T>::get(h),
-				Some(RequestStatus::Requested { deposit: None, count: 10, len: Some(65536) })
+				Some(OldRequestStatus::Requested { deposit: None, count: 10, len: Some(65536) })
 			);
 		});
 	}

substrate/frame/preimage/src/mock.rs

@@ -22,13 +22,13 @@ use super::*;
 use crate as pallet_preimage;
 use frame_support::{
 	ord_parameter_types,
-	traits::{ConstU32, ConstU64, Everything},
+	traits::{fungible::HoldConsideration, ConstU32, ConstU64, Everything},
 	weights::constants::RocksDbWeight,
 };
 use frame_system::EnsureSignedBy;
 use sp_core::H256;
 use sp_runtime::{
-	traits::{BlakeTwo256, IdentityLookup},
+	traits::{BlakeTwo256, Convert, IdentityLookup},
 	BuildStorage,
 };
 
@@ -80,22 +80,28 @@ impl pallet_balances::Config for Test {
 	type MaxReserves = ConstU32<50>;
 	type ReserveIdentifier = [u8; 8];
 	type FreezeIdentifier = ();
-	type MaxFreezes = ();
+	type MaxFreezes = ConstU32<1>;
 	type RuntimeHoldReason = ();
-	type MaxHolds = ();
+	type MaxHolds = ConstU32<2>;
 }
 
 ord_parameter_types! {
 	pub const One: u64 = 1;
 }
 
+pub struct ConvertDeposit;
+impl Convert<Footprint, u64> for ConvertDeposit {
+	fn convert(a: Footprint) -> u64 {
+		a.count * 2 + a.size
+	}
+}
+
 impl Config for Test {
 	type WeightInfo = ();
 	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
 	type ManagerOrigin = EnsureSignedBy<One, u64>;
-	type BaseDeposit = ConstU64<2>;
-	type ByteDeposit = ConstU64<1>;
+	type Consideration = HoldConsideration<u64, Balances, (), ConvertDeposit>;
 }
 
 pub fn new_test_ext() -> sp_io::TestExternalities {
@@ -110,3 +116,20 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
 pub fn hashed(data: impl AsRef<[u8]>) -> H256 {
 	BlakeTwo256::hash(data.as_ref())
 }
+
+/// Insert an un-migrated preimage.
+pub fn insert_old_unrequested<T: Config>(
+	s: u32,
+	acc: T::AccountId,
+) -> <T as frame_system::Config>::Hash {
+	// 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
+}

substrate/frame/preimage/src/tests.rs

@@ -24,12 +24,11 @@ use crate::mock::*;
 
 use frame_support::{
 	assert_err, assert_noop, assert_ok, assert_storage_noop,
-	traits::{Bounded, BoundedInline, Hash as PreimageHash},
+	traits::{fungible::InspectHold, Bounded, BoundedInline, Hash as PreimageHash},
 	StorageNoopGuard,
 };
-use pallet_balances::Error as BalancesError;
 use sp_core::{blake2_256, H256};
-use sp_runtime::bounded_vec;
+use sp_runtime::{bounded_vec, TokenError};
 
 /// Returns one `Inline`, `Lookup` and `Legacy` item each with different data and hash.
 pub fn make_bounded_values() -> (Bounded<Vec<u8>>, Bounded<Vec<u8>>, Bounded<Vec<u8>>) {
@@ -52,7 +51,7 @@ pub fn make_bounded_values() -> (Bounded<Vec<u8>>, Bounded<Vec<u8>>, Bounded<Vec
 fn user_note_preimage_works() {
 	new_test_ext().execute_with(|| {
 		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]));
-		assert_eq!(Balances::reserved_balance(2), 3);
+		assert_eq!(Balances::balance_on_hold(&(), &2), 3);
 		assert_eq!(Balances::free_balance(2), 97);
 
 		let h = hashed([1]);
@@ -61,11 +60,11 @@ fn user_note_preimage_works() {
 
 		assert_noop!(
 			Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]),
-			Error::<Test>::AlreadyNoted
+			Error::<Test>::AlreadyNoted,
 		);
 		assert_noop!(
 			Preimage::note_preimage(RuntimeOrigin::signed(0), vec![2]),
-			BalancesError::<Test>::InsufficientBalance
+			TokenError::FundsUnavailable,
 		);
 	});
 }
@@ -171,7 +170,7 @@ fn request_note_order_makes_no_difference() {
 		assert_ok!(Preimage::request_preimage(RuntimeOrigin::signed(1), hashed([1])));
 		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]));
 		(
-			StatusFor::<Test>::iter().collect::<Vec<_>>(),
+			RequestStatusFor::<Test>::iter().collect::<Vec<_>>(),
 			PreimageFor::<Test>::iter().collect::<Vec<_>>(),
 		)
 	});
@@ -180,7 +179,7 @@ fn request_note_order_makes_no_difference() {
 		assert_ok!(Preimage::request_preimage(RuntimeOrigin::signed(1), hashed([1])));
 		assert_ok!(Preimage::unnote_preimage(RuntimeOrigin::signed(2), hashed([1])));
 		let other_way = (
-			StatusFor::<Test>::iter().collect::<Vec<_>>(),
+			RequestStatusFor::<Test>::iter().collect::<Vec<_>>(),
 			PreimageFor::<Test>::iter().collect::<Vec<_>>(),
 		);
 		assert_eq!(one_way, other_way);
@@ -207,7 +206,7 @@ fn request_user_note_order_makes_no_difference() {
 		assert_ok!(Preimage::request_preimage(RuntimeOrigin::signed(1), hashed([1])));
 		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]));
 		(
-			StatusFor::<Test>::iter().collect::<Vec<_>>(),
+			RequestStatusFor::<Test>::iter().collect::<Vec<_>>(),
 			PreimageFor::<Test>::iter().collect::<Vec<_>>(),
 		)
 	});
@@ -216,7 +215,7 @@ fn request_user_note_order_makes_no_difference() {
 		assert_ok!(Preimage::request_preimage(RuntimeOrigin::signed(1), hashed([1])));
 		assert_ok!(Preimage::unnote_preimage(RuntimeOrigin::signed(2), hashed([1])));
 		let other_way = (
-			StatusFor::<Test>::iter().collect::<Vec<_>>(),
+			RequestStatusFor::<Test>::iter().collect::<Vec<_>>(),
 			PreimageFor::<Test>::iter().collect::<Vec<_>>(),
 		);
 		assert_eq!(one_way, other_way);
@@ -249,13 +248,14 @@ fn unrequest_preimage_works() {
 fn user_noted_then_requested_preimage_is_refunded_once_only() {
 	new_test_ext().execute_with(|| {
 		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1; 3]));
+		assert_eq!(Balances::balance_on_hold(&(), &2), 5);
 		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]));
+		assert_eq!(Balances::balance_on_hold(&(), &2), 8);
 		assert_ok!(Preimage::request_preimage(RuntimeOrigin::signed(1), hashed([1])));
 		assert_ok!(Preimage::unrequest_preimage(RuntimeOrigin::signed(1), hashed([1])));
 		assert_ok!(Preimage::unnote_preimage(RuntimeOrigin::signed(2), hashed([1])));
-		// Still have reserve from `vec[1; 3]`.
-		assert_eq!(Balances::reserved_balance(2), 5);
-		assert_eq!(Balances::free_balance(2), 95);
+		// Still have hold from `vec[1; 3]`.
+		assert_eq!(Balances::balance_on_hold(&(), &2), 5);
 	});
 }
 
@@ -270,7 +270,7 @@ fn noted_preimage_use_correct_map() {
 		assert_eq!(PreimageFor::<Test>::iter().count(), 8);
 
 		// All are present
-		assert_eq!(StatusFor::<Test>::iter().count(), 8);
+		assert_eq!(RequestStatusFor::<Test>::iter().count(), 8);
 
 		// Now start removing them again...
 		for i in 0..7 {
@@ -287,7 +287,7 @@ fn noted_preimage_use_correct_map() {
 		assert_eq!(PreimageFor::<Test>::iter().count(), 0);
 
 		// All are gone
-		assert_eq!(StatusFor::<Test>::iter().count(), 0);
+		assert_eq!(RequestStatusFor::<Test>::iter().count(), 0);
 	});
 }
 
@@ -327,20 +327,20 @@ fn query_and_store_preimage_workflow() {
 		Preimage::request(&hash);
 		// It is requested thrice.
 		assert!(matches!(
-			StatusFor::<Test>::get(&hash).unwrap(),
+			RequestStatusFor::<Test>::get(&hash).unwrap(),
 			RequestStatus::Requested { count: 3, .. }
 		));
 
 		// It can be realized and decoded correctly.
 		assert_eq!(Preimage::realize::<Vec<u8>>(&bound).unwrap(), (data.clone(), Some(len)));
 		assert!(matches!(
-			StatusFor::<Test>::get(&hash).unwrap(),
+			RequestStatusFor::<Test>::get(&hash).unwrap(),
 			RequestStatus::Requested { count: 2, .. }
 		));
 		// Dropping should unrequest.
 		Preimage::drop(&bound);
 		assert!(matches!(
-			StatusFor::<Test>::get(&hash).unwrap(),
+			RequestStatusFor::<Test>::get(&hash).unwrap(),
 			RequestStatus::Requested { count: 1, .. }
 		));
 
@@ -381,7 +381,7 @@ fn query_preimage_request_works() {
 		assert!(<Preimage as QueryPreimage>::len(&hash).is_none());
 		assert_noop!(<Preimage as QueryPreimage>::fetch(&hash, None), DispatchError::Unavailable);
 		// But there is only one entry in the map.
-		assert_eq!(StatusFor::<Test>::iter().count(), 1);
+		assert_eq!(RequestStatusFor::<Test>::iter().count(), 1);
 
 		// Un-request the preimage.
 		<Preimage as QueryPreimage>::unrequest(&hash);
@@ -392,7 +392,7 @@ fn query_preimage_request_works() {
 		// It is not requested anymore.
 		assert!(!<Preimage as QueryPreimage>::is_requested(&hash));
 		// And there is no entry in the map.
-		assert_eq!(StatusFor::<Test>::iter().count(), 0);
+		assert_eq!(RequestStatusFor::<Test>::iter().count(), 0);
 	});
 }
 
@@ -413,7 +413,7 @@ fn query_preimage_hold_and_drop_work() {
 		assert!(<Preimage as QueryPreimage>::is_requested(&legacy.hash()));
 
 		// There are two values requested in total.
-		assert_eq!(StatusFor::<Test>::iter().count(), 2);
+		assert_eq!(RequestStatusFor::<Test>::iter().count(), 2);
 
 		// Cleanup by dropping both.
 		<Preimage as QueryPreimage>::drop(&lookup);
@@ -422,7 +422,7 @@ fn query_preimage_hold_and_drop_work() {
 		assert!(!<Preimage as QueryPreimage>::is_requested(&legacy.hash()));
 
 		// There are no values requested anymore.
-		assert_eq!(StatusFor::<Test>::iter().count(), 0);
+		assert_eq!(RequestStatusFor::<Test>::iter().count(), 0);
 	});
 }
 
@@ -489,3 +489,27 @@ fn store_preimage_bound_too_large_errors() {
 		assert_ok!(<Preimage as StorePreimage>::bound(data.clone()));
 	});
 }
+
+#[test]
+fn ensure_updated_works() {
+	#![allow(deprecated)]
+	new_test_ext().execute_with(|| {
+		let alice = 2;
+
+		for i in 0..100 {
+			let hashes =
+				(0..100).map(|j| insert_old_unrequested::<Test>(j, alice)).collect::<Vec<_>>();
+			let old = hashes.iter().take(i).cloned().collect::<Vec<_>>();
+			let bad = vec![hashed([0; 32]); 100 - i];
+
+			let hashes = [old.as_slice(), bad.as_slice()].concat();
+			let res = Preimage::ensure_updated(RuntimeOrigin::signed(alice), hashes).unwrap();
+
+			// Alice pays a fee when less than 90% of the hashes are new.
+			assert_eq!(res.pays_fee, (i < 90).into());
+
+			assert_eq!(RequestStatusFor::<Test>::iter().count(), i);
+			assert_eq!(StatusFor::<Test>::iter().count(), 100 - i);
+		}
+	});
+}

substrate/frame/preimage/src/weights.rs

@@ -15,32 +15,29 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! Autogenerated weights for pallet_preimage
+//! Autogenerated weights for `pallet_preimage`
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-09-06, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
-//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+//! HOSTNAME: `runner-mia4uyug-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
+// 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=*
-// --execution=wasm
 // --wasm-execution=compiled
 // --heap-pages=4096
-// --output=./frame/preimage/src/weights.rs
-// --header=./HEADER-APACHE2
-// --template=./.maintain/frame-weight-template.hbs
+// --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)]
 #![allow(unused_parens)]
@@ -50,7 +47,7 @@
 use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
 use core::marker::PhantomData;
 
-/// Weight functions needed for pallet_preimage.
+/// Weight functions needed for `pallet_preimage`.
 pub trait WeightInfo {
 	fn note_preimage(s: u32, ) -> Weight;
 	fn note_requested_preimage(s: u32, ) -> Weight;
@@ -64,319 +61,410 @@ pub trait WeightInfo {
 	fn unrequest_preimage() -> Weight;
 	fn unrequest_unnoted_preimage() -> Weight;
 	fn unrequest_multi_referenced_preimage() -> Weight;
+	fn ensure_updated(n: u32, ) -> Weight;
 }
 
-/// Weights for pallet_preimage using the Substrate node and recommended hardware.
+/// Weights for `pallet_preimage` using the Substrate node and recommended hardware.
 pub struct SubstrateWeight<T>(PhantomData<T>);
 impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
-	/// Storage: Preimage PreimageFor (r:0 w:1)
-	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::PreimageFor` (r:0 w:1)
+	/// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`)
 	/// The range of component `s` is `[0, 4194304]`.
 	fn note_preimage(s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `143`
+		//  Measured:  `42`
 		//  Estimated: `3556`
-		// Minimum execution time: 30_479_000 picoseconds.
-		Weight::from_parts(23_381_775, 3556)
-			// Standard Error: 2
-			.saturating_add(Weight::from_parts(1_670, 0).saturating_mul(s.into()))
-			.saturating_add(T::DbWeight::get().reads(1_u64))
+		// Minimum execution time: 15_936_000 picoseconds.
+		Weight::from_parts(16_271_000, 3556)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(1_916, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
-	/// Storage: Preimage PreimageFor (r:0 w:1)
-	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::PreimageFor` (r:0 w:1)
+	/// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`)
 	/// The range of component `s` is `[0, 4194304]`.
 	fn note_requested_preimage(s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 16_104_000 picoseconds.
-		Weight::from_parts(18_393_879, 3556)
+		// Minimum execution time: 16_468_000 picoseconds.
+		Weight::from_parts(17_031_000, 3556)
 			// Standard Error: 2
-			.saturating_add(Weight::from_parts(1_669, 0).saturating_mul(s.into()))
-			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(Weight::from_parts(1_948, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
-	/// Storage: Preimage PreimageFor (r:0 w:1)
-	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::PreimageFor` (r:0 w:1)
+	/// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`)
 	/// The range of component `s` is `[0, 4194304]`.
 	fn note_no_deposit_preimage(s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 15_652_000 picoseconds.
-		Weight::from_parts(22_031_627, 3556)
-			// Standard Error: 2
-			.saturating_add(Weight::from_parts(1_672, 0).saturating_mul(s.into()))
-			.saturating_add(T::DbWeight::get().reads(1_u64))
+		// Minimum execution time: 16_342_000 picoseconds.
+		Weight::from_parts(16_535_000, 3556)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(1_906, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
-	/// Storage: Preimage PreimageFor (r:0 w:1)
-	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::PreimageFor` (r:0 w:1)
+	/// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`)
 	fn unnote_preimage() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `289`
+		//  Measured:  `172`
 		//  Estimated: `3556`
-		// Minimum execution time: 37_148_000 picoseconds.
-		Weight::from_parts(40_247_000, 3556)
-			.saturating_add(T::DbWeight::get().reads(1_u64))
+		// Minimum execution time: 31_047_000 picoseconds.
+		Weight::from_parts(34_099_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
-	/// Storage: Preimage PreimageFor (r:0 w:1)
-	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::PreimageFor` (r:0 w:1)
+	/// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`)
 	fn unnote_no_deposit_preimage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `144`
 		//  Estimated: `3556`
-		// Minimum execution time: 19_909_000 picoseconds.
-		Weight::from_parts(21_572_000, 3556)
-			.saturating_add(T::DbWeight::get().reads(1_u64))
+		// Minimum execution time: 32_559_000 picoseconds.
+		Weight::from_parts(36_677_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
 	fn request_preimage() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `188`
+		//  Measured:  `172`
 		//  Estimated: `3556`
-		// Minimum execution time: 17_602_000 picoseconds.
-		Weight::from_parts(18_899_000, 3556)
-			.saturating_add(T::DbWeight::get().reads(1_u64))
+		// Minimum execution time: 27_887_000 picoseconds.
+		Weight::from_parts(30_303_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
 	fn request_no_deposit_preimage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `144`
 		//  Estimated: `3556`
-		// Minimum execution time: 11_253_000 picoseconds.
-		Weight::from_parts(11_667_000, 3556)
-			.saturating_add(T::DbWeight::get().reads(1_u64))
+		// Minimum execution time: 17_256_000 picoseconds.
+		Weight::from_parts(19_481_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
 	fn request_unnoted_preimage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `42`
 		//  Estimated: `3556`
-		// Minimum execution time: 14_152_000 picoseconds.
-		Weight::from_parts(14_652_000, 3556)
-			.saturating_add(T::DbWeight::get().reads(1_u64))
+		// Minimum execution time: 22_344_000 picoseconds.
+		Weight::from_parts(23_868_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
 	fn request_requested_preimage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 8_267_000 picoseconds.
-		Weight::from_parts(8_969_000, 3556)
-			.saturating_add(T::DbWeight::get().reads(1_u64))
+		// Minimum execution time: 10_542_000 picoseconds.
+		Weight::from_parts(11_571_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
-	/// Storage: Preimage PreimageFor (r:0 w:1)
-	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::PreimageFor` (r:0 w:1)
+	/// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`)
 	fn unrequest_preimage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `144`
 		//  Estimated: `3556`
-		// Minimum execution time: 18_429_000 picoseconds.
-		Weight::from_parts(18_946_000, 3556)
-			.saturating_add(T::DbWeight::get().reads(1_u64))
+		// Minimum execution time: 29_054_000 picoseconds.
+		Weight::from_parts(32_996_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(2_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
 	fn unrequest_unnoted_preimage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 7_910_000 picoseconds.
-		Weight::from_parts(8_272_000, 3556)
-			.saturating_add(T::DbWeight::get().reads(1_u64))
+		// Minimum execution time: 10_775_000 picoseconds.
+		Weight::from_parts(11_937_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
 	fn unrequest_multi_referenced_preimage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 7_936_000 picoseconds.
-		Weight::from_parts(8_504_000, 3556)
-			.saturating_add(T::DbWeight::get().reads(1_u64))
+		// Minimum execution time: 10_696_000 picoseconds.
+		Weight::from_parts(11_717_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64))
 	}
+	/// Storage: `Preimage::StatusFor` (r:1024 w:1024)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:0 w:1024)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 1024]`.
+	fn ensure_updated(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `193 + n * (91 ±0)`
+		//  Estimated: `3593 + n * (2566 ±0)`
+		// Minimum execution time: 2_452_000 picoseconds.
+		Weight::from_parts(2_641_000, 3593)
+			// Standard Error: 19_797
+			.saturating_add(Weight::from_parts(15_620_946, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2566).saturating_mul(n.into()))
+	}
 }
 
-// For backwards compatibility and tests
+// For backwards compatibility and tests.
 impl WeightInfo for () {
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
-	/// Storage: Preimage PreimageFor (r:0 w:1)
-	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::PreimageFor` (r:0 w:1)
+	/// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`)
 	/// The range of component `s` is `[0, 4194304]`.
 	fn note_preimage(s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `143`
+		//  Measured:  `42`
 		//  Estimated: `3556`
-		// Minimum execution time: 30_479_000 picoseconds.
-		Weight::from_parts(23_381_775, 3556)
-			// Standard Error: 2
-			.saturating_add(Weight::from_parts(1_670, 0).saturating_mul(s.into()))
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
+		// Minimum execution time: 15_936_000 picoseconds.
+		Weight::from_parts(16_271_000, 3556)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(1_916, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
-	/// Storage: Preimage PreimageFor (r:0 w:1)
-	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::PreimageFor` (r:0 w:1)
+	/// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`)
 	/// The range of component `s` is `[0, 4194304]`.
 	fn note_requested_preimage(s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 16_104_000 picoseconds.
-		Weight::from_parts(18_393_879, 3556)
+		// Minimum execution time: 16_468_000 picoseconds.
+		Weight::from_parts(17_031_000, 3556)
 			// Standard Error: 2
-			.saturating_add(Weight::from_parts(1_669, 0).saturating_mul(s.into()))
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(Weight::from_parts(1_948, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
-	/// Storage: Preimage PreimageFor (r:0 w:1)
-	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::PreimageFor` (r:0 w:1)
+	/// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`)
 	/// The range of component `s` is `[0, 4194304]`.
 	fn note_no_deposit_preimage(s: u32, ) -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 15_652_000 picoseconds.
-		Weight::from_parts(22_031_627, 3556)
-			// Standard Error: 2
-			.saturating_add(Weight::from_parts(1_672, 0).saturating_mul(s.into()))
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
+		// Minimum execution time: 16_342_000 picoseconds.
+		Weight::from_parts(16_535_000, 3556)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(1_906, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
-	/// Storage: Preimage PreimageFor (r:0 w:1)
-	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::PreimageFor` (r:0 w:1)
+	/// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`)
 	fn unnote_preimage() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `289`
+		//  Measured:  `172`
 		//  Estimated: `3556`
-		// Minimum execution time: 37_148_000 picoseconds.
-		Weight::from_parts(40_247_000, 3556)
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
+		// Minimum execution time: 31_047_000 picoseconds.
+		Weight::from_parts(34_099_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
-	/// Storage: Preimage PreimageFor (r:0 w:1)
-	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::PreimageFor` (r:0 w:1)
+	/// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`)
 	fn unnote_no_deposit_preimage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `144`
 		//  Estimated: `3556`
-		// Minimum execution time: 19_909_000 picoseconds.
-		Weight::from_parts(21_572_000, 3556)
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
+		// Minimum execution time: 32_559_000 picoseconds.
+		Weight::from_parts(36_677_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
 	fn request_preimage() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `188`
+		//  Measured:  `172`
 		//  Estimated: `3556`
-		// Minimum execution time: 17_602_000 picoseconds.
-		Weight::from_parts(18_899_000, 3556)
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
+		// Minimum execution time: 27_887_000 picoseconds.
+		Weight::from_parts(30_303_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
 	fn request_no_deposit_preimage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `144`
 		//  Estimated: `3556`
-		// Minimum execution time: 11_253_000 picoseconds.
-		Weight::from_parts(11_667_000, 3556)
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
+		// Minimum execution time: 17_256_000 picoseconds.
+		Weight::from_parts(19_481_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
 	fn request_unnoted_preimage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `42`
 		//  Estimated: `3556`
-		// Minimum execution time: 14_152_000 picoseconds.
-		Weight::from_parts(14_652_000, 3556)
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
+		// Minimum execution time: 22_344_000 picoseconds.
+		Weight::from_parts(23_868_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
 	fn request_requested_preimage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 8_267_000 picoseconds.
-		Weight::from_parts(8_969_000, 3556)
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
+		// Minimum execution time: 10_542_000 picoseconds.
+		Weight::from_parts(11_571_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
-	/// Storage: Preimage PreimageFor (r:0 w:1)
-	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::PreimageFor` (r:0 w:1)
+	/// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`)
 	fn unrequest_preimage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `144`
 		//  Estimated: `3556`
-		// Minimum execution time: 18_429_000 picoseconds.
-		Weight::from_parts(18_946_000, 3556)
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
+		// Minimum execution time: 29_054_000 picoseconds.
+		Weight::from_parts(32_996_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(2_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
 	fn unrequest_unnoted_preimage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 7_910_000 picoseconds.
-		Weight::from_parts(8_272_000, 3556)
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
+		// Minimum execution time: 10_775_000 picoseconds.
+		Weight::from_parts(11_937_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
-	/// Storage: Preimage StatusFor (r:1 w:1)
-	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: `Preimage::StatusFor` (r:1 w:0)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:1 w:1)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
 	fn unrequest_multi_referenced_preimage() -> Weight {
 		// Proof Size summary in bytes:
 		//  Measured:  `106`
 		//  Estimated: `3556`
-		// Minimum execution time: 7_936_000 picoseconds.
-		Weight::from_parts(8_504_000, 3556)
-			.saturating_add(RocksDbWeight::get().reads(1_u64))
+		// Minimum execution time: 10_696_000 picoseconds.
+		Weight::from_parts(11_717_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
 			.saturating_add(RocksDbWeight::get().writes(1_u64))
 	}
+	/// Storage: `Preimage::StatusFor` (r:1024 w:1024)
+	/// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Preimage::RequestStatusFor` (r:0 w:1024)
+	/// Proof: `Preimage::RequestStatusFor` (`max_values`: None, `max_size`: Some(75), added: 2550, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 1024]`.
+	fn ensure_updated(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `193 + n * (91 ±0)`
+		//  Estimated: `3593 + n * (2566 ±0)`
+		// Minimum execution time: 2_452_000 picoseconds.
+		Weight::from_parts(2_641_000, 3593)
+			// Standard Error: 19_797
+			.saturating_add(Weight::from_parts(15_620_946, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2566).saturating_mul(n.into()))
+	}
 }

substrate/frame/referenda/src/mock.rs

@@ -89,8 +89,7 @@ impl pallet_preimage::Config for Test {
 	type WeightInfo = ();
 	type Currency = Balances;
 	type ManagerOrigin = EnsureRoot<u64>;
-	type BaseDeposit = ();
-	type ByteDeposit = ();
+	type Consideration = ();
 }
 impl pallet_scheduler::Config for Test {
 	type RuntimeEvent = RuntimeEvent;

substrate/frame/scheduler/src/mock.rs

@@ -100,7 +100,7 @@ frame_support::construct_runtime!(
 		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
 		Logger: logger::{Pallet, Call, Event<T>},
 		Scheduler: scheduler::{Pallet, Call, Storage, Event<T>},
-		Preimage: pallet_preimage::{Pallet, Call, Storage, Event<T>},
+		Preimage: pallet_preimage::{Pallet, Call, Storage, Event<T>, HoldReason},
 	}
 );
 
@@ -155,8 +155,7 @@ impl pallet_preimage::Config for Test {
 	type WeightInfo = ();
 	type Currency = ();
 	type ManagerOrigin = EnsureRoot<u64>;
-	type BaseDeposit = ();
-	type ByteDeposit = ();
+	type Consideration = ();
 }
 
 pub struct TestWeightInfo;

substrate/frame/support/src/dispatch.rs

@@ -138,6 +138,15 @@ impl From<Pays> for PostDispatchInfo {
 	}
 }
 
+impl From<bool> for Pays {
+	fn from(b: bool) -> Self {
+		match b {
+			true => Self::Yes,
+			false => Self::No,
+		}
+	}
+}
+
 /// A generalized group of dispatch types.
 ///
 /// NOTE whenever upgrading the enum make sure to also update

substrate/frame/support/src/traits.rs

@@ -90,8 +90,8 @@ pub use hooks::{
 pub mod schedule;
 mod storage;
 pub use storage::{
-	Consideration, Footprint, Incrementable, Instance, PartialStorageInfoTrait, StorageInfo,
-	StorageInfoTrait, StorageInstance, TrackedStorageKey, WhitelistedStorageKeys,
+	Consideration, Footprint, Incrementable, Instance, LinearStoragePrice, PartialStorageInfoTrait,
+	StorageInfo, StorageInfoTrait, StorageInstance, TrackedStorageKey, WhitelistedStorageKeys,
 };
 
 mod dispatch;

substrate/frame/support/src/traits/storage.rs

@@ -18,11 +18,13 @@
 //! Traits for encoding data related to pallet's storage items.
 
 use codec::{Encode, FullCodec, MaxEncodedLen};
+use core::marker::PhantomData;
 use impl_trait_for_tuples::impl_for_tuples;
 use scale_info::TypeInfo;
 pub use sp_core::storage::TrackedStorageKey;
+use sp_core::Get;
 use sp_runtime::{
-	traits::{Member, Saturating},
+	traits::{Convert, Member, Saturating},
 	DispatchError, RuntimeDebug,
 };
 use sp_std::{collections::btree_set::BTreeSet, prelude::*};
@@ -152,6 +154,20 @@ impl Footprint {
 	}
 }
 
+/// A storage price that increases linearly with the number of elements and their size.
+pub struct LinearStoragePrice<Base, Slope, Balance>(PhantomData<(Base, Slope, Balance)>);
+impl<Base, Slope, Balance> Convert<Footprint, Balance> for LinearStoragePrice<Base, Slope, Balance>
+where
+	Base: Get<Balance>,
+	Slope: Get<Balance>,
+	Balance: From<u64> + sp_runtime::Saturating,
+{
+	fn convert(a: Footprint) -> Balance {
+		let s: Balance = (a.count.saturating_mul(a.size)).into();
+		s.saturating_mul(Slope::get()).saturating_add(Base::get())
+	}
+}
+
 /// Some sort of cost taken from account temporarily in order to offset the cost to the chain of
 /// holding some data [`Footprint`] in state.
 ///
@@ -239,3 +255,25 @@ where
 }
 
 impl_incrementable!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128);
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::ConstU64;
+
+	#[test]
+	fn linear_storage_price_works() {
+		type Linear = LinearStoragePrice<ConstU64<7>, ConstU64<3>, u64>;
+		let p = |count, size| Linear::convert(Footprint { count, size });
+
+		assert_eq!(p(0, 0), 7);
+		assert_eq!(p(0, 1), 7);
+		assert_eq!(p(1, 0), 7);
+
+		assert_eq!(p(1, 1), 10);
+		assert_eq!(p(8, 1), 31);
+		assert_eq!(p(1, 8), 31);
+
+		assert_eq!(p(u64::MAX, u64::MAX), u64::MAX);
+	}
+}

substrate/frame/whitelist/src/mock.rs

@@ -90,8 +90,7 @@ impl pallet_preimage::Config for Test {
 	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
 	type ManagerOrigin = EnsureRoot<Self::AccountId>;
-	type BaseDeposit = ConstU64<1>;
-	type ByteDeposit = ConstU64<1>;
+	type Consideration = ();
 	type WeightInfo = ();
 }