Preimage registrar and Scheduler integration (#10356)

* initial idea * more * fix compile * add clear and request logic * improve some docs * Add and implement trait * continuing to improve * refcount type * infallible system preimage upload * fmt * fix requests * Make it simple * Make it simple * Formatting * Initial draft * request when scheduled * Docs * Scheduler good * Scheduler good * Scheduler tests working * Add new files * Missing stuff * Repotting, add weights. * Add some tests to preimage pallet * More tests * Fix benchmarks * preimage benchmarks * All preimage benchmarks * Tidy cargo * Update weights.rs * Allow hash provision in benchmarks * Initial work on new benchmarks for Scheduler * Tests working, refactor looks good * Tests for new Scheduler functionality * Use real weight, make tests work with runtimes without Preimage * Rename * Update benchmarks * Formatting * Formatting * Fix weird formatting * Update frame/preimage/src/lib.rs * Fix try-runtime build * Fixes * Fixes * Update frame/support/src/traits/tokens/currency.rs Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com> * Update frame/support/src/traits/tokens/currency/reservable.rs Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com> * Update frame/support/src/traits/tokens/imbalance.rs Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com> * Update frame/preimage/src/mock.rs Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com> * Update frame/scheduler/src/lib.rs Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com> * Update frame/preimage/src/lib.rs * Fixes * Fixes * Formatting * Fixes * Fixes * cargo run --quiet --release --features=runtime-benchmarks --manifest-path=bin/node/cli/Cargo.toml -- benchmark --chain=dev --steps=50 --repeat=20 --pallet=pallet_scheduler --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./frame/scheduler/src/weights.rs --template=./.maintain/frame-weight-template.hbs * cargo run --quiet --release --features=runtime-benchmarks --manifest-path=bin/node/cli/Cargo.toml -- benchmark --chain=dev --steps=50 --repeat=20 --pallet=pallet_preimage --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./frame/preimage/src/weights.rs --template=./.maintain/frame-weight-template.hbs Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com> Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com> Co-authored-by: Guillaume Thiolliere <gui.thiolliere@gmail.com> Co-authored-by: Parity Bot <admin@parity.io>
2026-06-12 17:01:09 +00:00 · 2021-12-11 15:55:23 +01:00
parent f6f58f95e1
commit 5e50e0bc2c
24 changed files with 3592 additions and 1287 deletions
@@ -53,8 +53,8 @@ pub use misc::{
 	Backing, ConstBool, ConstI128, ConstI16, ConstI32, ConstI64, ConstI8, ConstU128, ConstU16,
 	ConstU32, ConstU64, ConstU8, EnsureInherentsAreFirst, EqualPrivilegeOnly, EstimateCallFee,
 	ExecuteBlock, ExtrinsicCall, Get, GetBacking, GetDefault, HandleLifetime, IsSubType, IsType,
-	Len, OffchainWorker, OnKilledAccount, OnNewAccount, PrivilegeCmp, SameOrOther, Time, TryDrop,
-	UnixTime, WrapperKeepOpaque, WrapperOpaque,
+	Len, OffchainWorker, OnKilledAccount, OnNewAccount, PreimageProvider, PreimageRecipient,
+	PrivilegeCmp, SameOrOther, Time, TryDrop, UnixTime, WrapperKeepOpaque, WrapperOpaque,
 };

 mod stored_map;
@@ -94,6 +94,12 @@ pub trait TryDrop: Sized {
 	fn try_drop(self) -> Result<(), Self>;
 }

+impl TryDrop for () {
+	fn try_drop(self) -> Result<(), Self> {
+		Ok(())
+	}
+}
+
 /// Return type used when we need to return one of two items, each of the opposite direction or
 /// sign, with one (`Same`) being of the same type as the `self` or primary argument of the function
 /// that returned it.
@@ -577,6 +583,65 @@ impl<T: TypeInfo + 'static> TypeInfo for WrapperKeepOpaque<T> {
 	}
 }

+/// A interface for looking up preimages from their hash on chain.
+pub trait PreimageProvider<Hash> {
+	/// Returns whether a preimage exists for a given hash.
+	///
+	/// A value of `true` implies that `get_preimage` is `Some`.
+	fn have_preimage(hash: &Hash) -> bool;
+
+	/// Returns the preimage for a given hash.
+	fn get_preimage(hash: &Hash) -> Option<Vec<u8>>;
+
+	/// Returns whether a preimage request exists for a given hash.
+	fn preimage_requested(hash: &Hash) -> bool;
+
+	/// Request that someone report a preimage. Providers use this to optimise the economics for
+	/// preimage reporting.
+	fn request_preimage(hash: &Hash);
+
+	/// Cancel a previous preimage request.
+	fn unrequest_preimage(hash: &Hash);
+}
+
+impl<Hash> PreimageProvider<Hash> for () {
+	fn have_preimage(_: &Hash) -> bool {
+		false
+	}
+	fn get_preimage(_: &Hash) -> Option<Vec<u8>> {
+		None
+	}
+	fn preimage_requested(_: &Hash) -> bool {
+		false
+	}
+	fn request_preimage(_: &Hash) {}
+	fn unrequest_preimage(_: &Hash) {}
+}
+
+/// A interface for managing preimages to hashes on chain.
+///
+/// Note that this API does not assume any underlying user is calling, and thus
+/// does not handle any preimage ownership or fees. Other system level logic that
+/// uses this API should implement that on their own side.
+pub trait PreimageRecipient<Hash>: PreimageProvider<Hash> {
+	/// Maximum size of a preimage.
+	type MaxSize: Get<u32>;
+
+	/// Store the bytes of a preimage on chain.
+	fn note_preimage(bytes: crate::BoundedVec<u8, Self::MaxSize>);
+
+	/// Clear a previously noted preimage. This is infallible and should be treated more like a
+	/// hint - if it was not previously noted or if it is now requested, then this will not do
+	/// anything.
+	fn unnote_preimage(hash: &Hash);
+}
+
+impl<Hash> PreimageRecipient<Hash> for () {
+	type MaxSize = ();
+	fn note_preimage(_: crate::BoundedVec<u8, Self::MaxSize>) {}
+	fn unnote_preimage(_: &Hash) {}
+}
+
 #[cfg(test)]
 mod test {
 	use super::*;
@@ -17,10 +17,10 @@

 //! Traits and associated utilities for scheduling dispatchables in FRAME.

-use codec::{Codec, Decode, Encode, EncodeLike};
+use codec::{Codec, Decode, Encode, EncodeLike, MaxEncodedLen};
 use scale_info::TypeInfo;
 use sp_runtime::{DispatchError, RuntimeDebug};
-use sp_std::{fmt::Debug, prelude::*};
+use sp_std::{fmt::Debug, prelude::*, result::Result};

 /// Information relating to the period of a scheduled task. First item is the length of the
 /// period and the second is the number of times it should be executed in total before the task
@@ -49,86 +49,323 @@ pub const HARD_DEADLINE: Priority = 63;
 /// The lowest priority. Most stuff should be around here.
 pub const LOWEST_PRIORITY: Priority = 255;

-/// A type that can be used as a scheduler.
-pub trait Anon<BlockNumber, Call, Origin> {
-	/// An address which can be used for removing a scheduled task.
-	type Address: Codec + Clone + Eq + EncodeLike + Debug;
-
-	/// Schedule a dispatch to happen at the beginning of some block in the future.
-	///
-	/// This is not named.
-	fn schedule(
-		when: DispatchTime<BlockNumber>,
-		maybe_periodic: Option<Period<BlockNumber>>,
-		priority: Priority,
-		origin: Origin,
-		call: Call,
-	) -> Result<Self::Address, DispatchError>;
-
-	/// Cancel a scheduled task. If periodic, then it will cancel all further instances of that,
-	/// also.
-	///
-	/// Will return an error if the `address` is invalid.
-	///
-	/// NOTE: This guaranteed to work only *before* the point that it is due to be executed.
-	/// If it ends up being delayed beyond the point of execution, then it cannot be cancelled.
-	///
-	/// NOTE2: This will not work to cancel periodic tasks after their initial execution. For
-	/// that, you must name the task explicitly using the `Named` trait.
-	fn cancel(address: Self::Address) -> Result<(), ()>;
-
-	/// Reschedule a task. For one-off tasks, this dispatch is guaranteed to succeed
-	/// only if it is executed *before* the currently scheduled block. For periodic tasks,
-	/// this dispatch is guaranteed to succeed only before the *initial* execution; for
-	/// others, use `reschedule_named`.
-	///
-	/// Will return an error if the `address` is invalid.
-	fn reschedule(
-		address: Self::Address,
-		when: DispatchTime<BlockNumber>,
-	) -> Result<Self::Address, DispatchError>;
-
-	/// Return the next dispatch time for a given task.
-	///
-	/// Will return an error if the `address` is invalid.
-	fn next_dispatch_time(address: Self::Address) -> Result<BlockNumber, ()>;
+/// Type representing an encodable value or the hash of the encoding of such a value.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum MaybeHashed<T, Hash> {
+	/// The value itself.
+	Value(T),
+	/// The hash of the encoded value which this value represents.
+	Hash(Hash),
 }

-/// A type that can be used as a scheduler.
-pub trait Named<BlockNumber, Call, Origin> {
-	/// An address which can be used for removing a scheduled task.
-	type Address: Codec + Clone + Eq + EncodeLike + sp_std::fmt::Debug;
-
-	/// Schedule a dispatch to happen at the beginning of some block in the future.
-	///
-	/// - `id`: The identity of the task. This must be unique and will return an error if not.
-	fn schedule_named(
-		id: Vec<u8>,
-		when: DispatchTime<BlockNumber>,
-		maybe_periodic: Option<Period<BlockNumber>>,
-		priority: Priority,
-		origin: Origin,
-		call: Call,
-	) -> Result<Self::Address, ()>;
-
-	/// Cancel a scheduled, named task. If periodic, then it will cancel all further instances
-	/// of that, also.
-	///
-	/// Will return an error if the `id` is invalid.
-	///
-	/// NOTE: This guaranteed to work only *before* the point that it is due to be executed.
-	/// If it ends up being delayed beyond the point of execution, then it cannot be cancelled.
-	fn cancel_named(id: Vec<u8>) -> Result<(), ()>;
-
-	/// Reschedule a task. For one-off tasks, this dispatch is guaranteed to succeed
-	/// only if it is executed *before* the currently scheduled block.
-	fn reschedule_named(
-		id: Vec<u8>,
-		when: DispatchTime<BlockNumber>,
-	) -> Result<Self::Address, DispatchError>;
-
-	/// Return the next dispatch time for a given task.
-	///
-	/// Will return an error if the `id` is invalid.
-	fn next_dispatch_time(id: Vec<u8>) -> Result<BlockNumber, ()>;
+impl<T, H> From<T> for MaybeHashed<T, H> {
+	fn from(t: T) -> Self {
+		MaybeHashed::Value(t)
+	}
 }
+
+/// Error type for `MaybeHashed::lookup`.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum LookupError {
+	/// A call of this hash was not known.
+	Unknown,
+	/// The preimage for this hash was known but could not be decoded into a `Call`.
+	BadFormat,
+}
+
+impl<T: Decode, H> MaybeHashed<T, H> {
+	pub fn as_value(&self) -> Option<&T> {
+		match &self {
+			Self::Value(c) => Some(c),
+			Self::Hash(_) => None,
+		}
+	}
+
+	pub fn as_hash(&self) -> Option<&H> {
+		match &self {
+			Self::Value(_) => None,
+			Self::Hash(h) => Some(h),
+		}
+	}
+
+	pub fn ensure_requested<P: PreimageProvider<H>>(&self) {
+		match &self {
+			Self::Value(_) => (),
+			Self::Hash(hash) => P::request_preimage(hash),
+		}
+	}
+
+	pub fn ensure_unrequested<P: PreimageProvider<H>>(&self) {
+		match &self {
+			Self::Value(_) => (),
+			Self::Hash(hash) => P::unrequest_preimage(hash),
+		}
+	}
+
+	pub fn resolved<P: PreimageProvider<H>>(self) -> (Self, Option<H>) {
+		match self {
+			Self::Value(c) => (Self::Value(c), None),
+			Self::Hash(h) => {
+				let data = match P::get_preimage(&h) {
+					Some(p) => p,
+					None => return (Self::Hash(h), None),
+				};
+				match T::decode(&mut &data[..]) {
+					Ok(c) => (Self::Value(c), Some(h)),
+					Err(_) => (Self::Hash(h), None),
+				}
+			},
+		}
+	}
+}
+
+pub mod v1 {
+	use super::*;
+
+	/// A type that can be used as a scheduler.
+	pub trait Anon<BlockNumber, Call, Origin> {
+		/// An address which can be used for removing a scheduled task.
+		type Address: Codec + Clone + Eq + EncodeLike + Debug;
+
+		/// Schedule a dispatch to happen at the beginning of some block in the future.
+		///
+		/// This is not named.
+		fn schedule(
+			when: DispatchTime<BlockNumber>,
+			maybe_periodic: Option<Period<BlockNumber>>,
+			priority: Priority,
+			origin: Origin,
+			call: Call,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Cancel a scheduled task. If periodic, then it will cancel all further instances of that,
+		/// also.
+		///
+		/// Will return an error if the `address` is invalid.
+		///
+		/// NOTE: This guaranteed to work only *before* the point that it is due to be executed.
+		/// If it ends up being delayed beyond the point of execution, then it cannot be cancelled.
+		///
+		/// NOTE2: This will not work to cancel periodic tasks after their initial execution. For
+		/// that, you must name the task explicitly using the `Named` trait.
+		fn cancel(address: Self::Address) -> Result<(), ()>;
+
+		/// Reschedule a task. For one-off tasks, this dispatch is guaranteed to succeed
+		/// only if it is executed *before* the currently scheduled block. For periodic tasks,
+		/// this dispatch is guaranteed to succeed only before the *initial* execution; for
+		/// others, use `reschedule_named`.
+		///
+		/// Will return an error if the `address` is invalid.
+		fn reschedule(
+			address: Self::Address,
+			when: DispatchTime<BlockNumber>,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Return the next dispatch time for a given task.
+		///
+		/// Will return an error if the `address` is invalid.
+		fn next_dispatch_time(address: Self::Address) -> Result<BlockNumber, ()>;
+	}
+
+	/// A type that can be used as a scheduler.
+	pub trait Named<BlockNumber, Call, Origin> {
+		/// An address which can be used for removing a scheduled task.
+		type Address: Codec + Clone + Eq + EncodeLike + sp_std::fmt::Debug;
+
+		/// Schedule a dispatch to happen at the beginning of some block in the future.
+		///
+		/// - `id`: The identity of the task. This must be unique and will return an error if not.
+		fn schedule_named(
+			id: Vec<u8>,
+			when: DispatchTime<BlockNumber>,
+			maybe_periodic: Option<Period<BlockNumber>>,
+			priority: Priority,
+			origin: Origin,
+			call: Call,
+		) -> Result<Self::Address, ()>;
+
+		/// Cancel a scheduled, named task. If periodic, then it will cancel all further instances
+		/// of that, also.
+		///
+		/// Will return an error if the `id` is invalid.
+		///
+		/// NOTE: This guaranteed to work only *before* the point that it is due to be executed.
+		/// If it ends up being delayed beyond the point of execution, then it cannot be cancelled.
+		fn cancel_named(id: Vec<u8>) -> Result<(), ()>;
+
+		/// Reschedule a task. For one-off tasks, this dispatch is guaranteed to succeed
+		/// only if it is executed *before* the currently scheduled block.
+		fn reschedule_named(
+			id: Vec<u8>,
+			when: DispatchTime<BlockNumber>,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Return the next dispatch time for a given task.
+		///
+		/// Will return an error if the `id` is invalid.
+		fn next_dispatch_time(id: Vec<u8>) -> Result<BlockNumber, ()>;
+	}
+
+	impl<T, BlockNumber, Call, Origin> Anon<BlockNumber, Call, Origin> for T
+	where
+		T: v2::Anon<BlockNumber, Call, Origin>,
+	{
+		type Address = T::Address;
+
+		fn schedule(
+			when: DispatchTime<BlockNumber>,
+			maybe_periodic: Option<Period<BlockNumber>>,
+			priority: Priority,
+			origin: Origin,
+			call: Call,
+		) -> Result<Self::Address, DispatchError> {
+			let c = MaybeHashed::<Call, T::Hash>::Value(call);
+			T::schedule(when, maybe_periodic, priority, origin, c)
+		}
+
+		fn cancel(address: Self::Address) -> Result<(), ()> {
+			T::cancel(address)
+		}
+
+		fn reschedule(
+			address: Self::Address,
+			when: DispatchTime<BlockNumber>,
+		) -> Result<Self::Address, DispatchError> {
+			T::reschedule(address, when)
+		}
+
+		fn next_dispatch_time(address: Self::Address) -> Result<BlockNumber, ()> {
+			T::next_dispatch_time(address)
+		}
+	}
+
+	impl<T, BlockNumber, Call, Origin> Named<BlockNumber, Call, Origin> for T
+	where
+		T: v2::Named<BlockNumber, Call, Origin>,
+	{
+		type Address = T::Address;
+
+		fn schedule_named(
+			id: Vec<u8>,
+			when: DispatchTime<BlockNumber>,
+			maybe_periodic: Option<Period<BlockNumber>>,
+			priority: Priority,
+			origin: Origin,
+			call: Call,
+		) -> Result<Self::Address, ()> {
+			let c = MaybeHashed::<Call, T::Hash>::Value(call);
+			T::schedule_named(id, when, maybe_periodic, priority, origin, c)
+		}
+
+		fn cancel_named(id: Vec<u8>) -> Result<(), ()> {
+			T::cancel_named(id)
+		}
+
+		fn reschedule_named(
+			id: Vec<u8>,
+			when: DispatchTime<BlockNumber>,
+		) -> Result<Self::Address, DispatchError> {
+			T::reschedule_named(id, when)
+		}
+
+		fn next_dispatch_time(id: Vec<u8>) -> Result<BlockNumber, ()> {
+			T::next_dispatch_time(id)
+		}
+	}
+}
+
+pub mod v2 {
+	use super::*;
+
+	/// A type that can be used as a scheduler.
+	pub trait Anon<BlockNumber, Call, Origin> {
+		/// An address which can be used for removing a scheduled task.
+		type Address: Codec + Clone + Eq + EncodeLike + Debug;
+		/// A means of expressing a call by the hash of its encoded data.
+		type Hash;
+
+		/// Schedule a dispatch to happen at the beginning of some block in the future.
+		///
+		/// This is not named.
+		fn schedule(
+			when: DispatchTime<BlockNumber>,
+			maybe_periodic: Option<Period<BlockNumber>>,
+			priority: Priority,
+			origin: Origin,
+			call: MaybeHashed<Call, Self::Hash>,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Cancel a scheduled task. If periodic, then it will cancel all further instances of that,
+		/// also.
+		///
+		/// Will return an error if the `address` is invalid.
+		///
+		/// NOTE: This guaranteed to work only *before* the point that it is due to be executed.
+		/// If it ends up being delayed beyond the point of execution, then it cannot be cancelled.
+		///
+		/// NOTE2: This will not work to cancel periodic tasks after their initial execution. For
+		/// that, you must name the task explicitly using the `Named` trait.
+		fn cancel(address: Self::Address) -> Result<(), ()>;
+
+		/// Reschedule a task. For one-off tasks, this dispatch is guaranteed to succeed
+		/// only if it is executed *before* the currently scheduled block. For periodic tasks,
+		/// this dispatch is guaranteed to succeed only before the *initial* execution; for
+		/// others, use `reschedule_named`.
+		///
+		/// Will return an error if the `address` is invalid.
+		fn reschedule(
+			address: Self::Address,
+			when: DispatchTime<BlockNumber>,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Return the next dispatch time for a given task.
+		///
+		/// Will return an error if the `address` is invalid.
+		fn next_dispatch_time(address: Self::Address) -> Result<BlockNumber, ()>;
+	}
+
+	/// A type that can be used as a scheduler.
+	pub trait Named<BlockNumber, Call, Origin> {
+		/// An address which can be used for removing a scheduled task.
+		type Address: Codec + Clone + Eq + EncodeLike + sp_std::fmt::Debug;
+		/// A means of expressing a call by the hash of its encoded data.
+		type Hash;
+
+		/// Schedule a dispatch to happen at the beginning of some block in the future.
+		///
+		/// - `id`: The identity of the task. This must be unique and will return an error if not.
+		fn schedule_named(
+			id: Vec<u8>,
+			when: DispatchTime<BlockNumber>,
+			maybe_periodic: Option<Period<BlockNumber>>,
+			priority: Priority,
+			origin: Origin,
+			call: MaybeHashed<Call, Self::Hash>,
+		) -> Result<Self::Address, ()>;
+
+		/// Cancel a scheduled, named task. If periodic, then it will cancel all further instances
+		/// of that, also.
+		///
+		/// Will return an error if the `id` is invalid.
+		///
+		/// NOTE: This guaranteed to work only *before* the point that it is due to be executed.
+		/// If it ends up being delayed beyond the point of execution, then it cannot be cancelled.
+		fn cancel_named(id: Vec<u8>) -> Result<(), ()>;
+
+		/// Reschedule a task. For one-off tasks, this dispatch is guaranteed to succeed
+		/// only if it is executed *before* the currently scheduled block.
+		fn reschedule_named(
+			id: Vec<u8>,
+			when: DispatchTime<BlockNumber>,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Return the next dispatch time for a given task.
+		///
+		/// Will return an error if the `id` is invalid.
+		fn next_dispatch_time(id: Vec<u8>) -> Result<BlockNumber, ()>;
+	}
+}
+
+pub use v1::*;
+
+use super::PreimageProvider;
@@ -199,3 +199,91 @@ pub trait Currency<AccountId> {
 		balance: Self::Balance,
 	) -> SignedImbalance<Self::Balance, Self::PositiveImbalance>;
 }
+
+#[cfg(feature = "std")]
+impl<AccountId> Currency<AccountId> for () {
+	type Balance = u32;
+	type PositiveImbalance = ();
+	type NegativeImbalance = ();
+	fn total_balance(_: &AccountId) -> Self::Balance {
+		0
+	}
+	fn can_slash(_: &AccountId, _: Self::Balance) -> bool {
+		true
+	}
+	fn total_issuance() -> Self::Balance {
+		0
+	}
+	fn minimum_balance() -> Self::Balance {
+		0
+	}
+	fn burn(_: Self::Balance) -> Self::PositiveImbalance {
+		()
+	}
+	fn issue(_: Self::Balance) -> Self::NegativeImbalance {
+		()
+	}
+	fn pair(_: Self::Balance) -> (Self::PositiveImbalance, Self::NegativeImbalance) {
+		((), ())
+	}
+	fn free_balance(_: &AccountId) -> Self::Balance {
+		0
+	}
+	fn ensure_can_withdraw(
+		_: &AccountId,
+		_: Self::Balance,
+		_: WithdrawReasons,
+		_: Self::Balance,
+	) -> DispatchResult {
+		Ok(())
+	}
+	fn transfer(
+		_: &AccountId,
+		_: &AccountId,
+		_: Self::Balance,
+		_: ExistenceRequirement,
+	) -> DispatchResult {
+		Ok(())
+	}
+	fn slash(_: &AccountId, _: Self::Balance) -> (Self::NegativeImbalance, Self::Balance) {
+		((), 0)
+	}
+	fn deposit_into_existing(
+		_: &AccountId,
+		_: Self::Balance,
+	) -> Result<Self::PositiveImbalance, DispatchError> {
+		Ok(())
+	}
+	fn resolve_into_existing(
+		_: &AccountId,
+		_: Self::NegativeImbalance,
+	) -> Result<(), Self::NegativeImbalance> {
+		Ok(())
+	}
+	fn deposit_creating(_: &AccountId, _: Self::Balance) -> Self::PositiveImbalance {
+		()
+	}
+	fn resolve_creating(_: &AccountId, _: Self::NegativeImbalance) {}
+	fn withdraw(
+		_: &AccountId,
+		_: Self::Balance,
+		_: WithdrawReasons,
+		_: ExistenceRequirement,
+	) -> Result<Self::NegativeImbalance, DispatchError> {
+		Ok(())
+	}
+	fn settle(
+		_: &AccountId,
+		_: Self::PositiveImbalance,
+		_: WithdrawReasons,
+		_: ExistenceRequirement,
+	) -> Result<(), Self::PositiveImbalance> {
+		Ok(())
+	}
+	fn make_free_balance_be(
+		_: &AccountId,
+		_: Self::Balance,
+	) -> SignedImbalance<Self::Balance, Self::PositiveImbalance> {
+		SignedImbalance::Positive(())
+	}
+}
@@ -81,6 +81,33 @@ pub trait ReservableCurrency<AccountId>: Currency<AccountId> {
 	) -> Result<Self::Balance, DispatchError>;
 }

+#[cfg(feature = "std")]
+impl<AccountId> ReservableCurrency<AccountId> for () {
+	fn can_reserve(_: &AccountId, _: Self::Balance) -> bool {
+		true
+	}
+	fn slash_reserved(_: &AccountId, _: Self::Balance) -> (Self::NegativeImbalance, Self::Balance) {
+		((), 0)
+	}
+	fn reserved_balance(_: &AccountId) -> Self::Balance {
+		0
+	}
+	fn reserve(_: &AccountId, _: Self::Balance) -> DispatchResult {
+		Ok(())
+	}
+	fn unreserve(_: &AccountId, _: Self::Balance) -> Self::Balance {
+		0
+	}
+	fn repatriate_reserved(
+		_: &AccountId,
+		_: &AccountId,
+		_: Self::Balance,
+		_: BalanceStatus,
+	) -> Result<Self::Balance, DispatchError> {
+		Ok(0)
+	}
+}
+
 pub trait NamedReservableCurrency<AccountId>: ReservableCurrency<AccountId> {
 	/// An identifier for a reserve. Used for disambiguating different reserves so that
 	/// they can be individually replaced or removed.
@@ -177,3 +177,55 @@ pub trait Imbalance<Balance>: Sized + TryDrop + Default {
 	/// The raw value of self.
 	fn peek(&self) -> Balance;
 }
+
+#[cfg(feature = "std")]
+impl<Balance: Default> Imbalance<Balance> for () {
+	type Opposite = ();
+	fn zero() -> Self {
+		()
+	}
+	fn drop_zero(self) -> Result<(), Self> {
+		Ok(())
+	}
+	fn split(self, _: Balance) -> (Self, Self) {
+		((), ())
+	}
+	fn ration(self, _: u32, _: u32) -> (Self, Self)
+	where
+		Balance: From<u32> + Saturating + Div<Output = Balance>,
+	{
+		((), ())
+	}
+	fn split_merge(self, _: Balance, _: (Self, Self)) -> (Self, Self) {
+		((), ())
+	}
+	fn ration_merge(self, _: u32, _: u32, _: (Self, Self)) -> (Self, Self)
+	where
+		Balance: From<u32> + Saturating + Div<Output = Balance>,
+	{
+		((), ())
+	}
+	fn split_merge_into(self, _: Balance, _: &mut (Self, Self)) {}
+	fn ration_merge_into(self, _: u32, _: u32, _: &mut (Self, Self))
+	where
+		Balance: From<u32> + Saturating + Div<Output = Balance>,
+	{
+	}
+	fn merge(self, _: Self) -> Self {
+		()
+	}
+	fn merge_into(self, _: &mut Self) {}
+	fn maybe_merge(self, _: Option<Self>) -> Self {
+		()
+	}
+	fn subsume(&mut self, _: Self) {}
+	fn maybe_subsume(&mut self, _: Option<Self>) {
+		()
+	}
+	fn offset(self, _: Self::Opposite) -> SameOrOther<Self, Self::Opposite> {
+		SameOrOther::None
+	}
+	fn peek(&self) -> Balance {
+		Default::default()
+	}
+}