From a477bd0ba546e419d7995681f87b5dad07f9bb5a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pablo=20Andr=C3=A9s=20Dorado=20Su=C3=A1rez?=
 <hola@pablodorado.com>
Date: Fri, 21 Jun 2024 09:36:37 -0500
Subject: [PATCH] Implement `pallet-assets-freezer` (#3951)

Closes #3342

cc/ @liamaharon

TODO:

- [x] Improve docs.
- [x] Define public interface (See #3342).
  In case we define public calls to the pallet implementation:
  - Implement public calls.
  - Benchmarks.

polkadot address: 12gMhxHw8QjEwLQvnqsmMVY1z5gFa54vND74aMUbhhwN6mJR

---------

Co-authored-by: command-bot <>
Co-authored-by: Liam Aharon <liam.aharon@hotmail.com>
---
 Cargo.lock                                    |  20 ++
 Cargo.toml                                    |   1 +
 .../assets/asset-hub-rococo/Cargo.toml        |   4 +
 .../assets/asset-hub-rococo/src/lib.rs        |  30 +-
 .../assets/asset-hub-westend/Cargo.toml       |   4 +
 .../assets/asset-hub-westend/src/lib.rs       |  30 +-
 prdoc/pr_3951.prdoc                           |  30 ++
 substrate/frame/assets-freezer/Cargo.toml     |  61 ++++
 substrate/frame/assets-freezer/src/impls.rs   | 158 +++++++++
 substrate/frame/assets-freezer/src/lib.rs     | 176 ++++++++++
 substrate/frame/assets-freezer/src/mock.rs    | 154 +++++++++
 substrate/frame/assets-freezer/src/tests.rs   | 304 ++++++++++++++++++
 substrate/frame/balances/src/lib.rs           |   4 +-
 substrate/frame/balances/src/types.rs         |   9 -
 substrate/frame/support/src/traits/tokens.rs  |   6 +-
 .../frame/support/src/traits/tokens/misc.rs   |  11 +-
 umbrella/Cargo.toml                           |  10 +-
 umbrella/src/lib.rs                           |   4 +
 18 files changed, 994 insertions(+), 22 deletions(-)
 create mode 100644 prdoc/pr_3951.prdoc
 create mode 100644 substrate/frame/assets-freezer/Cargo.toml
 create mode 100644 substrate/frame/assets-freezer/src/impls.rs
 create mode 100644 substrate/frame/assets-freezer/src/lib.rs
 create mode 100644 substrate/frame/assets-freezer/src/mock.rs
 create mode 100644 substrate/frame/assets-freezer/src/tests.rs

diff --git a/Cargo.lock b/Cargo.lock
index 5f3e3c3603e..7f58c4b9361 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -823,6 +823,7 @@ dependencies = [
  "pallet-asset-conversion-ops",
  "pallet-asset-conversion-tx-payment",
  "pallet-assets",
+ "pallet-assets-freezer",
  "pallet-aura",
  "pallet-authorship",
  "pallet-balances",
@@ -956,6 +957,7 @@ dependencies = [
  "pallet-asset-conversion-ops",
  "pallet-asset-conversion-tx-payment",
  "pallet-assets",
+ "pallet-assets-freezer",
  "pallet-aura",
  "pallet-authorship",
  "pallet-balances",
@@ -9546,6 +9548,23 @@ dependencies = [
  "sp-std 14.0.0",
 ]
 
+[[package]]
+name = "pallet-assets-freezer"
+version = "0.1.0"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-assets",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+]
+
 [[package]]
 name = "pallet-atomic-swap"
 version = "28.0.0"
@@ -14017,6 +14036,7 @@ dependencies = [
  "pallet-asset-rate",
  "pallet-asset-tx-payment",
  "pallet-assets",
+ "pallet-assets-freezer",
  "pallet-atomic-swap",
  "pallet-aura",
  "pallet-authority-discovery",
diff --git a/Cargo.toml b/Cargo.toml
index 2b2a1cdc17d..ba52b0179ff 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -306,6 +306,7 @@ members = [
 	"substrate/frame/asset-conversion/ops",
 	"substrate/frame/asset-rate",
 	"substrate/frame/assets",
+	"substrate/frame/assets-freezer",
 	"substrate/frame/atomic-swap",
 	"substrate/frame/aura",
 	"substrate/frame/authority-discovery",
diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/Cargo.toml b/cumulus/parachains/runtimes/assets/asset-hub-rococo/Cargo.toml
index a880730ddac..b8670c2957d 100644
--- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/Cargo.toml
+++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/Cargo.toml
@@ -28,6 +28,7 @@ pallet-asset-conversion-tx-payment = { path = "../../../../../substrate/frame/tr
 pallet-assets = { path = "../../../../../substrate/frame/assets", default-features = false }
 pallet-asset-conversion-ops = { path = "../../../../../substrate/frame/asset-conversion/ops", default-features = false }
 pallet-asset-conversion = { path = "../../../../../substrate/frame/asset-conversion", default-features = false }
+pallet-assets-freezer = { path = "../../../../../substrate/frame/assets-freezer", default-features = false }
 pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false }
 pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false }
 pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false }
@@ -116,6 +117,7 @@ runtime-benchmarks = [
 	"frame-system/runtime-benchmarks",
 	"pallet-asset-conversion-ops/runtime-benchmarks",
 	"pallet-asset-conversion/runtime-benchmarks",
+	"pallet-assets-freezer/runtime-benchmarks",
 	"pallet-assets/runtime-benchmarks",
 	"pallet-balances/runtime-benchmarks",
 	"pallet-collator-selection/runtime-benchmarks",
@@ -151,6 +153,7 @@ try-runtime = [
 	"pallet-asset-conversion-ops/try-runtime",
 	"pallet-asset-conversion-tx-payment/try-runtime",
 	"pallet-asset-conversion/try-runtime",
+	"pallet-assets-freezer/try-runtime",
 	"pallet-assets/try-runtime",
 	"pallet-aura/try-runtime",
 	"pallet-authorship/try-runtime",
@@ -200,6 +203,7 @@ std = [
 	"pallet-asset-conversion-ops/std",
 	"pallet-asset-conversion-tx-payment/std",
 	"pallet-asset-conversion/std",
+	"pallet-assets-freezer/std",
 	"pallet-assets/std",
 	"pallet-aura/std",
 	"pallet-authorship/std",
diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/lib.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/lib.rs
index 5bba1b568d9..423f9549edc 100644
--- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/lib.rs
+++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/lib.rs
@@ -257,7 +257,7 @@ impl pallet_assets::Config<TrustBackedAssetsInstance> for Runtime {
 	type MetadataDepositPerByte = MetadataDepositPerByte;
 	type ApprovalDeposit = ApprovalDeposit;
 	type StringLimit = AssetsStringLimit;
-	type Freezer = ();
+	type Freezer = AssetsFreezer;
 	type Extra = ();
 	type WeightInfo = weights::pallet_assets_local::WeightInfo<Runtime>;
 	type CallbackHandle = ();
@@ -267,6 +267,13 @@ impl pallet_assets::Config<TrustBackedAssetsInstance> for Runtime {
 	type BenchmarkHelper = ();
 }
 
+// Allow Freezes for the `Assets` pallet
+pub type AssetsFreezerInstance = pallet_assets_freezer::Instance1;
+impl pallet_assets_freezer::Config<AssetsFreezerInstance> for Runtime {
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RuntimeEvent = RuntimeEvent;
+}
+
 parameter_types! {
 	pub const AssetConversionPalletId: PalletId = PalletId(*b"py/ascon");
 	pub const LiquidityWithdrawalFee: Permill = Permill::from_percent(0);
@@ -295,7 +302,7 @@ impl pallet_assets::Config<PoolAssetsInstance> for Runtime {
 	type MetadataDepositPerByte = ConstU128<0>;
 	type ApprovalDeposit = ApprovalDeposit;
 	type StringLimit = ConstU32<50>;
-	type Freezer = ();
+	type Freezer = PoolAssetsFreezer;
 	type Extra = ();
 	type WeightInfo = weights::pallet_assets_pool::WeightInfo<Runtime>;
 	type CallbackHandle = ();
@@ -303,6 +310,13 @@ impl pallet_assets::Config<PoolAssetsInstance> for Runtime {
 	type BenchmarkHelper = ();
 }
 
+// Allow Freezes for the `PoolAssets` pallet
+pub type PoolAssetsFreezerInstance = pallet_assets_freezer::Instance3;
+impl pallet_assets_freezer::Config<PoolAssetsFreezerInstance> for Runtime {
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RuntimeEvent = RuntimeEvent;
+}
+
 /// Union fungibles implementation for `Assets` and `ForeignAssets`.
 pub type LocalAndForeignAssets = fungibles::UnionOf<
 	Assets,
@@ -411,7 +425,7 @@ impl pallet_assets::Config<ForeignAssetsInstance> for Runtime {
 	type MetadataDepositPerByte = ForeignAssetsMetadataDepositPerByte;
 	type ApprovalDeposit = ForeignAssetsApprovalDeposit;
 	type StringLimit = ForeignAssetsAssetsStringLimit;
-	type Freezer = ();
+	type Freezer = ForeignAssetsFreezer;
 	type Extra = ();
 	type WeightInfo = weights::pallet_assets_foreign::WeightInfo<Runtime>;
 	type CallbackHandle = ();
@@ -421,6 +435,13 @@ impl pallet_assets::Config<ForeignAssetsInstance> for Runtime {
 	type BenchmarkHelper = xcm_config::XcmBenchmarkHelper;
 }
 
+// Allow Freezes for the `ForeignAssets` pallet
+pub type ForeignAssetsFreezerInstance = pallet_assets_freezer::Instance2;
+impl pallet_assets_freezer::Config<ForeignAssetsFreezerInstance> for Runtime {
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RuntimeEvent = RuntimeEvent;
+}
+
 parameter_types! {
 	// One storage item; key size is 32; value is size 4+4+16+32 bytes = 56 bytes.
 	pub const DepositBase: Balance = deposit(1, 88);
@@ -953,6 +974,9 @@ construct_runtime!(
 		NftFractionalization: pallet_nft_fractionalization = 54,
 		PoolAssets: pallet_assets::<Instance3> = 55,
 		AssetConversion: pallet_asset_conversion = 56,
+		AssetsFreezer: pallet_assets_freezer::<Instance1> = 57,
+		ForeignAssetsFreezer: pallet_assets_freezer::<Instance2> = 58,
+		PoolAssetsFreezer: pallet_assets_freezer::<Instance3> = 59,
 
 		// TODO: the pallet instance should be removed once all pools have migrated
 		// to the new account IDs.
diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/Cargo.toml b/cumulus/parachains/runtimes/assets/asset-hub-westend/Cargo.toml
index 953f6a8b400..f310b2e0313 100644
--- a/cumulus/parachains/runtimes/assets/asset-hub-westend/Cargo.toml
+++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/Cargo.toml
@@ -28,6 +28,7 @@ pallet-asset-conversion-ops = { path = "../../../../../substrate/frame/asset-con
 pallet-asset-conversion-tx-payment = { path = "../../../../../substrate/frame/transaction-payment/asset-conversion-tx-payment", default-features = false }
 pallet-assets = { path = "../../../../../substrate/frame/assets", default-features = false }
 pallet-asset-conversion = { path = "../../../../../substrate/frame/asset-conversion", default-features = false }
+pallet-assets-freezer = { path = "../../../../../substrate/frame/assets-freezer", default-features = false }
 pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false }
 pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false }
 pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false }
@@ -115,6 +116,7 @@ runtime-benchmarks = [
 	"frame-system/runtime-benchmarks",
 	"pallet-asset-conversion-ops/runtime-benchmarks",
 	"pallet-asset-conversion/runtime-benchmarks",
+	"pallet-assets-freezer/runtime-benchmarks",
 	"pallet-assets/runtime-benchmarks",
 	"pallet-balances/runtime-benchmarks",
 	"pallet-collator-selection/runtime-benchmarks",
@@ -150,6 +152,7 @@ try-runtime = [
 	"pallet-asset-conversion-ops/try-runtime",
 	"pallet-asset-conversion-tx-payment/try-runtime",
 	"pallet-asset-conversion/try-runtime",
+	"pallet-assets-freezer/try-runtime",
 	"pallet-assets/try-runtime",
 	"pallet-aura/try-runtime",
 	"pallet-authorship/try-runtime",
@@ -200,6 +203,7 @@ std = [
 	"pallet-asset-conversion-ops/std",
 	"pallet-asset-conversion-tx-payment/std",
 	"pallet-asset-conversion/std",
+	"pallet-assets-freezer/std",
 	"pallet-assets/std",
 	"pallet-aura/std",
 	"pallet-authorship/std",
diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs
index dcf9565f330..6764242cc33 100644
--- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs
+++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs
@@ -255,7 +255,7 @@ impl pallet_assets::Config<TrustBackedAssetsInstance> for Runtime {
 	type MetadataDepositPerByte = MetadataDepositPerByte;
 	type ApprovalDeposit = ApprovalDeposit;
 	type StringLimit = AssetsStringLimit;
-	type Freezer = ();
+	type Freezer = AssetsFreezer;
 	type Extra = ();
 	type WeightInfo = weights::pallet_assets_local::WeightInfo<Runtime>;
 	type CallbackHandle = ();
@@ -265,6 +265,13 @@ impl pallet_assets::Config<TrustBackedAssetsInstance> for Runtime {
 	type BenchmarkHelper = ();
 }
 
+// Allow Freezes for the `Assets` pallet
+pub type AssetsFreezerInstance = pallet_assets_freezer::Instance1;
+impl pallet_assets_freezer::Config<AssetsFreezerInstance> for Runtime {
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RuntimeEvent = RuntimeEvent;
+}
+
 parameter_types! {
 	pub const AssetConversionPalletId: PalletId = PalletId(*b"py/ascon");
 	pub const LiquidityWithdrawalFee: Permill = Permill::from_percent(0);
@@ -292,7 +299,7 @@ impl pallet_assets::Config<PoolAssetsInstance> for Runtime {
 	type MetadataDepositPerByte = ConstU128<0>;
 	type ApprovalDeposit = ConstU128<0>;
 	type StringLimit = ConstU32<50>;
-	type Freezer = ();
+	type Freezer = PoolAssetsFreezer;
 	type Extra = ();
 	type WeightInfo = weights::pallet_assets_pool::WeightInfo<Runtime>;
 	type CallbackHandle = ();
@@ -300,6 +307,13 @@ impl pallet_assets::Config<PoolAssetsInstance> for Runtime {
 	type BenchmarkHelper = ();
 }
 
+// Allow Freezes for the `PoolAssets` pallet
+pub type PoolAssetsFreezerInstance = pallet_assets_freezer::Instance3;
+impl pallet_assets_freezer::Config<PoolAssetsFreezerInstance> for Runtime {
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RuntimeEvent = RuntimeEvent;
+}
+
 /// Union fungibles implementation for `Assets` and `ForeignAssets`.
 pub type LocalAndForeignAssets = fungibles::UnionOf<
 	Assets,
@@ -405,7 +419,7 @@ impl pallet_assets::Config<ForeignAssetsInstance> for Runtime {
 	type MetadataDepositPerByte = ForeignAssetsMetadataDepositPerByte;
 	type ApprovalDeposit = ForeignAssetsApprovalDeposit;
 	type StringLimit = ForeignAssetsAssetsStringLimit;
-	type Freezer = ();
+	type Freezer = ForeignAssetsFreezer;
 	type Extra = ();
 	type WeightInfo = weights::pallet_assets_foreign::WeightInfo<Runtime>;
 	type CallbackHandle = ();
@@ -415,6 +429,13 @@ impl pallet_assets::Config<ForeignAssetsInstance> for Runtime {
 	type BenchmarkHelper = xcm_config::XcmBenchmarkHelper;
 }
 
+// Allow Freezes for the `ForeignAssets` pallet
+pub type ForeignAssetsFreezerInstance = pallet_assets_freezer::Instance2;
+impl pallet_assets_freezer::Config<ForeignAssetsFreezerInstance> for Runtime {
+	type RuntimeFreezeReason = RuntimeFreezeReason;
+	type RuntimeEvent = RuntimeEvent;
+}
+
 parameter_types! {
 	// One storage item; key size is 32; value is size 4+4+16+32 bytes = 56 bytes.
 	pub const DepositBase: Balance = deposit(1, 88);
@@ -943,6 +964,9 @@ construct_runtime!(
 		NftFractionalization: pallet_nft_fractionalization = 54,
 		PoolAssets: pallet_assets::<Instance3> = 55,
 		AssetConversion: pallet_asset_conversion = 56,
+		AssetsFreezer: pallet_assets_freezer::<Instance1> = 57,
+		ForeignAssetsFreezer: pallet_assets_freezer::<Instance2> = 58,
+		PoolAssetsFreezer: pallet_assets_freezer::<Instance3> = 59,
 
 		StateTrieMigration: pallet_state_trie_migration = 70,
 
diff --git a/prdoc/pr_3951.prdoc b/prdoc/pr_3951.prdoc
new file mode 100644
index 00000000000..3a8096e6f44
--- /dev/null
+++ b/prdoc/pr_3951.prdoc
@@ -0,0 +1,30 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Pallet Assets Freezer
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      This pallet is an extension of `pallet-assets`, supporting  
+      freezes similar to `pallet-balances`. 
+      To use this pallet, set `Freezer` of `pallet-assets` Config to the according instance of
+      `pallet-assets-freezer`.
+  - audience: Runtime User
+    description: |
+      The storage of this pallet contains a Vecs of account freezes. Applications UIs and Developer
+      Tools might benefit from observing it.
+
+crates:
+  - name: frame-support
+    bump: minor
+  - name: pallet-assets-freezer
+    bump: major
+  - name: pallet-assets
+    bump: patch
+  - name: pallet-balances
+    bump: patch
+  - name: asset-hub-rococo-runtime
+    bump: minor
+  - name: asset-hub-westend-runtime
+    bump: minor
diff --git a/substrate/frame/assets-freezer/Cargo.toml b/substrate/frame/assets-freezer/Cargo.toml
new file mode 100644
index 00000000000..d7b5d2d40c4
--- /dev/null
+++ b/substrate/frame/assets-freezer/Cargo.toml
@@ -0,0 +1,61 @@
+[package]
+name = "pallet-assets-freezer"
+version = "0.1.0"
+authors.workspace = true
+edition.workspace = true
+license = "MIT-0"
+homepage = "https://substrate.io"
+repository.workspace = true
+description = "Provides freezing features to `pallet-assets`"
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+log = { workspace = true }
+scale-info = { version = "2.10.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { path = "../benchmarking", default-features = false, optional = true }
+frame-support = { path = "../support", default-features = false }
+frame-system = { path = "../system", default-features = false }
+pallet-assets = { path = "../assets", default-features = false }
+sp-runtime = { path = "../../primitives/runtime", default-features = false }
+
+[dev-dependencies]
+sp-io = { path = "../../primitives/io", default-features = false }
+sp-core = { path = "../../primitives/core", default-features = false }
+pallet-balances = { path = "../balances", default-features = false }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-assets/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-assets/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-assets/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/assets-freezer/src/impls.rs b/substrate/frame/assets-freezer/src/impls.rs
new file mode 100644
index 00000000000..cd383f1c3cd
--- /dev/null
+++ b/substrate/frame/assets-freezer/src/impls.rs
@@ -0,0 +1,158 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::*;
+
+use frame_support::traits::{
+	fungibles::{Inspect, InspectFreeze, MutateFreeze},
+	tokens::{DepositConsequence, Fortitude, Preservation, Provenance, WithdrawConsequence},
+};
+use pallet_assets::FrozenBalance;
+use sp_runtime::traits::Zero;
+
+// Implements [`FrozenBalance`] from [`pallet-assets`], so it can understand how much of an
+// account balance is frozen, and is able to signal to this pallet when to clear the state of an
+// account.
+impl<T: Config<I>, I: 'static> FrozenBalance<T::AssetId, T::AccountId, T::Balance>
+	for Pallet<T, I>
+{
+	fn frozen_balance(asset: T::AssetId, who: &T::AccountId) -> Option<T::Balance> {
+		FrozenBalances::<T, I>::get(asset, who)
+	}
+
+	fn died(asset: T::AssetId, who: &T::AccountId) {
+		FrozenBalances::<T, I>::remove(asset.clone(), who);
+		Freezes::<T, I>::remove(asset, who);
+	}
+}
+
+// Implement [`fungibles::Inspect`](frame_support::traits::fungibles::Inspect) as it is bound by
+// [`fungibles::InspectFreeze`](frame_support::traits::fungibles::InspectFreeze) and
+// [`fungibles::MutateFreeze`](frame_support::traits::fungibles::MutateFreeze). To do so, we'll
+// re-export all of `pallet-assets` implementation of the same trait.
+impl<T: Config<I>, I: 'static> Inspect<T::AccountId> for Pallet<T, I> {
+	type AssetId = T::AssetId;
+	type Balance = T::Balance;
+
+	fn total_issuance(asset: Self::AssetId) -> Self::Balance {
+		pallet_assets::Pallet::<T, I>::total_issuance(asset)
+	}
+
+	fn minimum_balance(asset: Self::AssetId) -> Self::Balance {
+		pallet_assets::Pallet::<T, I>::minimum_balance(asset)
+	}
+
+	fn total_balance(asset: Self::AssetId, who: &T::AccountId) -> Self::Balance {
+		pallet_assets::Pallet::<T, I>::total_balance(asset, who)
+	}
+
+	fn balance(asset: Self::AssetId, who: &T::AccountId) -> Self::Balance {
+		pallet_assets::Pallet::<T, I>::balance(asset, who)
+	}
+
+	fn reducible_balance(
+		asset: Self::AssetId,
+		who: &T::AccountId,
+		preservation: Preservation,
+		force: Fortitude,
+	) -> Self::Balance {
+		pallet_assets::Pallet::<T, I>::reducible_balance(asset, who, preservation, force)
+	}
+
+	fn can_deposit(
+		asset: Self::AssetId,
+		who: &T::AccountId,
+		amount: Self::Balance,
+		provenance: Provenance,
+	) -> DepositConsequence {
+		pallet_assets::Pallet::<T, I>::can_deposit(asset, who, amount, provenance)
+	}
+
+	fn can_withdraw(
+		asset: Self::AssetId,
+		who: &T::AccountId,
+		amount: Self::Balance,
+	) -> WithdrawConsequence<Self::Balance> {
+		pallet_assets::Pallet::<T, I>::can_withdraw(asset, who, amount)
+	}
+
+	fn asset_exists(asset: Self::AssetId) -> bool {
+		pallet_assets::Pallet::<T, I>::asset_exists(asset)
+	}
+}
+
+impl<T: Config<I>, I: 'static> InspectFreeze<T::AccountId> for Pallet<T, I> {
+	type Id = T::RuntimeFreezeReason;
+
+	fn balance_frozen(asset: Self::AssetId, id: &Self::Id, who: &T::AccountId) -> Self::Balance {
+		let freezes = Freezes::<T, I>::get(asset, who);
+		freezes.into_iter().find(|l| &l.id == id).map_or(Zero::zero(), |l| l.amount)
+	}
+
+	fn can_freeze(asset: Self::AssetId, id: &Self::Id, who: &T::AccountId) -> bool {
+		let freezes = Freezes::<T, I>::get(asset, who);
+		!freezes.is_full() || freezes.into_iter().any(|i| i.id == *id)
+	}
+}
+
+impl<T: Config<I>, I: 'static> MutateFreeze<T::AccountId> for Pallet<T, I> {
+	fn set_freeze(
+		asset: Self::AssetId,
+		id: &Self::Id,
+		who: &T::AccountId,
+		amount: Self::Balance,
+	) -> sp_runtime::DispatchResult {
+		if amount.is_zero() {
+			return Self::thaw(asset, id, who);
+		}
+		let mut freezes = Freezes::<T, I>::get(asset.clone(), who);
+		if let Some(i) = freezes.iter_mut().find(|i| &i.id == id) {
+			i.amount = amount;
+		} else {
+			freezes
+				.try_push(IdAmount { id: *id, amount })
+				.map_err(|_| Error::<T, I>::TooManyFreezes)?;
+		}
+		Self::update_freezes(asset, who, freezes.as_bounded_slice())
+	}
+
+	fn extend_freeze(
+		asset: Self::AssetId,
+		id: &Self::Id,
+		who: &T::AccountId,
+		amount: Self::Balance,
+	) -> sp_runtime::DispatchResult {
+		if amount.is_zero() {
+			return Ok(());
+		}
+		let mut freezes = Freezes::<T, I>::get(asset.clone(), who);
+		if let Some(i) = freezes.iter_mut().find(|x| &x.id == id) {
+			i.amount = i.amount.max(amount);
+		} else {
+			freezes
+				.try_push(IdAmount { id: *id, amount })
+				.map_err(|_| Error::<T, I>::TooManyFreezes)?;
+		}
+		Self::update_freezes(asset, who, freezes.as_bounded_slice())
+	}
+
+	fn thaw(asset: Self::AssetId, id: &Self::Id, who: &T::AccountId) -> sp_runtime::DispatchResult {
+		let mut freezes = Freezes::<T, I>::get(asset.clone(), who);
+		freezes.retain(|f| &f.id != id);
+		Self::update_freezes(asset, who, freezes.as_bounded_slice())
+	}
+}
diff --git a/substrate/frame/assets-freezer/src/lib.rs b/substrate/frame/assets-freezer/src/lib.rs
new file mode 100644
index 00000000000..b42d41ac1d9
--- /dev/null
+++ b/substrate/frame/assets-freezer/src/lib.rs
@@ -0,0 +1,176 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! # Assets Freezer Pallet
+//!
+//! A pallet capable of freezing fungibles from `pallet-assets`. This is an extension of
+//! `pallet-assets`, wrapping [`fungibles::Inspect`](`frame_support::traits::fungibles::Inspect`).
+//! It implements both
+//! [`fungibles::freeze::Inspect`](frame_support::traits::fungibles::freeze::Inspect) and
+//! [`fungibles::freeze::Mutate`](frame_support::traits::fungibles::freeze::Mutate). The complexity
+//! of the operations is `O(n)`. where `n` is the variant count of `RuntimeFreezeReason`.
+//!
+//! ## Pallet API
+//!
+//! See the [`pallet`] module for more information about the interfaces this pallet exposes,
+//! including its configuration trait, dispatchables, storage items, events and errors.
+//!
+//! ## Overview
+//!
+//! This pallet provides the following functionality:
+//!
+//! - Pallet hooks allowing [`pallet-assets`] to know the frozen balance for an account on a given
+//!   asset (see [`pallet_assets::FrozenBalance`]).
+//! - An implementation of
+//!   [`fungibles::freeze::Inspect`](frame_support::traits::fungibles::freeze::Inspect) and
+//!   [`fungibles::freeze::Mutate`](frame_support::traits::fungibles::freeze::Mutate), allowing
+//!   other pallets to manage freezes for the `pallet-assets` assets.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::{
+	pallet_prelude::*,
+	traits::{tokens::IdAmount, VariantCount, VariantCountOf},
+	BoundedVec,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use sp_runtime::{
+	traits::{Saturating, Zero},
+	BoundedSlice,
+};
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+mod impls;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+
+	#[pallet::config(with_default)]
+	pub trait Config<I: 'static = ()>: frame_system::Config + pallet_assets::Config<I> {
+		/// The overarching freeze reason.
+		#[pallet::no_default_bounds]
+		type RuntimeFreezeReason: Parameter + Member + MaxEncodedLen + Copy + VariantCount;
+
+		/// The overarching event type.
+		#[pallet::no_default_bounds]
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Number of freezes on an account would exceed `MaxFreezes`.
+		TooManyFreezes,
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		// `who`s frozen balance was increased by `amount`.
+		Frozen { who: T::AccountId, asset_id: T::AssetId, amount: T::Balance },
+		// `who`s frozen balance was decreased by `amount`.
+		Thawed { who: T::AccountId, asset_id: T::AssetId, amount: T::Balance },
+	}
+
+	/// A map that stores freezes applied on an account for a given AssetId.
+	#[pallet::storage]
+	pub(super) type Freezes<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::AssetId,
+		Blake2_128Concat,
+		T::AccountId,
+		BoundedVec<
+			IdAmount<T::RuntimeFreezeReason, T::Balance>,
+			VariantCountOf<T::RuntimeFreezeReason>,
+		>,
+		ValueQuery,
+	>;
+
+	/// A map that stores the current total frozen balance for every account on a given AssetId.
+	#[pallet::storage]
+	pub(super) type FrozenBalances<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::AssetId,
+		Blake2_128Concat,
+		T::AccountId,
+		T::Balance,
+	>;
+
+	#[pallet::hooks]
+	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
+		#[cfg(feature = "try-runtime")]
+		fn try_state(_: BlockNumberFor<T>) -> Result<(), sp_runtime::TryRuntimeError> {
+			Self::do_try_state()
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	fn update_freezes(
+		asset: T::AssetId,
+		who: &T::AccountId,
+		freezes: BoundedSlice<
+			IdAmount<T::RuntimeFreezeReason, T::Balance>,
+			VariantCountOf<T::RuntimeFreezeReason>,
+		>,
+	) -> DispatchResult {
+		let prev_frozen = FrozenBalances::<T, I>::get(asset.clone(), who).unwrap_or_default();
+		let after_frozen = freezes.into_iter().map(|f| f.amount).max().unwrap_or_else(Zero::zero);
+		FrozenBalances::<T, I>::set(asset.clone(), who, Some(after_frozen));
+		if freezes.is_empty() {
+			Freezes::<T, I>::remove(asset.clone(), who);
+			FrozenBalances::<T, I>::remove(asset.clone(), who);
+		} else {
+			Freezes::<T, I>::insert(asset.clone(), who, freezes);
+		}
+		if prev_frozen > after_frozen {
+			let amount = prev_frozen.saturating_sub(after_frozen);
+			Self::deposit_event(Event::Thawed { asset_id: asset, who: who.clone(), amount });
+		} else if after_frozen > prev_frozen {
+			let amount = after_frozen.saturating_sub(prev_frozen);
+			Self::deposit_event(Event::Frozen { asset_id: asset, who: who.clone(), amount });
+		}
+		Ok(())
+	}
+
+	#[cfg(any(test, feature = "try-runtime"))]
+	fn do_try_state() -> Result<(), sp_runtime::TryRuntimeError> {
+		for (asset, who, _) in FrozenBalances::<T, I>::iter() {
+			let max_frozen_amount =
+				Freezes::<T, I>::get(asset.clone(), who.clone()).iter().map(|l| l.amount).max();
+
+			frame_support::ensure!(
+				FrozenBalances::<T, I>::get(asset, who) == max_frozen_amount,
+				"The `FrozenAmount` is not equal to the maximum amount in `Freezes` for (`asset`, `who`)"
+			);
+		}
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/assets-freezer/src/mock.rs b/substrate/frame/assets-freezer/src/mock.rs
new file mode 100644
index 00000000000..b4e8c857fba
--- /dev/null
+++ b/substrate/frame/assets-freezer/src/mock.rs
@@ -0,0 +1,154 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Tests mock for `pallet-assets-freezer`.
+
+use crate as pallet_assets_freezer;
+pub use crate::*;
+use codec::{Compact, Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	derive_impl,
+	traits::{AsEnsureOriginWithArg, ConstU64},
+};
+use scale_info::TypeInfo;
+use sp_core::{ConstU32, H256};
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+pub type AccountId = u64;
+pub type Balance = u64;
+pub type AssetId = u32;
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Assets: pallet_assets,
+		AssetsFreezer: pallet_assets_freezer,
+		Balances: pallet_balances,
+	}
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type Hash = H256;
+	type RuntimeCall = RuntimeCall;
+	type Hashing = BlakeTwo256;
+	type AccountId = AccountId;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU64<250>;
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<u64>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+impl pallet_balances::Config for Test {
+	type MaxLocks = ();
+	type MaxReserves = ();
+	type ReserveIdentifier = [u8; 8];
+	type Balance = Balance;
+	type DustRemoval = ();
+	type RuntimeEvent = RuntimeEvent;
+	type ExistentialDeposit = ConstU64<1>;
+	type AccountStore = System;
+	type WeightInfo = ();
+	type FreezeIdentifier = ();
+	type MaxFreezes = ();
+	type RuntimeHoldReason = ();
+	type RuntimeFreezeReason = ();
+}
+
+impl pallet_assets::Config for Test {
+	type AssetId = AssetId;
+	type AssetIdParameter = Compact<AssetId>;
+	type AssetDeposit = ConstU64<1>;
+	type Balance = Balance;
+	type AssetAccountDeposit = ConstU64<1>;
+	type MetadataDepositBase = ();
+	type MetadataDepositPerByte = ();
+	type ApprovalDeposit = ();
+	type CreateOrigin = AsEnsureOriginWithArg<frame_system::EnsureSigned<u64>>;
+	type ForceOrigin = frame_system::EnsureRoot<u64>;
+	type StringLimit = ConstU32<32>;
+	type Extra = ();
+	type RemoveItemsLimit = ConstU32<10>;
+	type CallbackHandle = ();
+	type Currency = Balances;
+	type Freezer = AssetsFreezer;
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+}
+
+#[derive(
+	Decode, Encode, MaxEncodedLen, PartialEq, Eq, Ord, PartialOrd, TypeInfo, Debug, Clone, Copy,
+)]
+pub enum DummyFreezeReason {
+	Governance,
+	Staking,
+	Other,
+}
+
+impl VariantCount for DummyFreezeReason {
+	// Intentionally set below the actual count of variants, to allow testing for `can_freeze`
+	const VARIANT_COUNT: u32 = 2;
+}
+
+impl Config for Test {
+	type RuntimeFreezeReason = DummyFreezeReason;
+	type RuntimeEvent = RuntimeEvent;
+}
+
+pub fn new_test_ext(execute: impl FnOnce()) -> sp_io::TestExternalities {
+	let t = RuntimeGenesisConfig {
+		assets: pallet_assets::GenesisConfig {
+			assets: vec![(1, 0, true, 1)],
+			metadata: vec![],
+			accounts: vec![(1, 1, 100)],
+		},
+		system: Default::default(),
+		balances: Default::default(),
+	}
+	.build_storage()
+	.unwrap();
+	let mut ext: sp_io::TestExternalities = t.into();
+	ext.execute_with(|| {
+		System::set_block_number(1);
+		execute();
+		frame_support::assert_ok!(AssetsFreezer::do_try_state());
+	});
+
+	ext
+}
diff --git a/substrate/frame/assets-freezer/src/tests.rs b/substrate/frame/assets-freezer/src/tests.rs
new file mode 100644
index 00000000000..4f2dea79c70
--- /dev/null
+++ b/substrate/frame/assets-freezer/src/tests.rs
@@ -0,0 +1,304 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Tests for pallet-assets-freezer.
+
+use crate::mock::*;
+
+use codec::Compact;
+use frame_support::{
+	assert_ok, assert_storage_noop,
+	traits::{
+		fungibles::{Inspect, InspectFreeze, MutateFreeze},
+		tokens::{Fortitude, Preservation},
+	},
+};
+use pallet_assets::FrozenBalance;
+
+const WHO: AccountId = 1;
+const ASSET_ID: AssetId = 1;
+
+fn test_set_freeze(id: DummyFreezeReason, amount: Balance) {
+	let mut freezes = Freezes::<Test>::get(ASSET_ID, WHO);
+
+	if let Some(i) = freezes.iter_mut().find(|l| l.id == id) {
+		i.amount = amount;
+	} else {
+		freezes
+			.try_push(IdAmount { id, amount })
+			.expect("freeze is added without exceeding bounds; qed");
+	}
+
+	assert_ok!(AssetsFreezer::update_freezes(ASSET_ID, &WHO, freezes.as_bounded_slice()));
+}
+
+fn test_thaw(id: DummyFreezeReason) {
+	let mut freezes = Freezes::<Test>::get(ASSET_ID, WHO);
+	freezes.retain(|l| l.id != id);
+
+	assert_ok!(AssetsFreezer::update_freezes(ASSET_ID, &WHO, freezes.as_bounded_slice()));
+}
+
+mod impl_frozen_balance {
+	use super::*;
+
+	#[test]
+	fn frozen_balance_works() {
+		new_test_ext(|| {
+			assert_eq!(AssetsFreezer::frozen_balance(ASSET_ID, &WHO), None);
+			test_set_freeze(DummyFreezeReason::Governance, 1);
+			assert_eq!(AssetsFreezer::frozen_balance(ASSET_ID, &WHO), Some(1u64));
+			test_set_freeze(DummyFreezeReason::Staking, 3);
+			assert_eq!(AssetsFreezer::frozen_balance(ASSET_ID, &WHO), Some(3u64));
+			test_set_freeze(DummyFreezeReason::Governance, 2);
+			assert_eq!(AssetsFreezer::frozen_balance(ASSET_ID, &WHO), Some(3u64));
+			// also test thawing works to reduce a balance, and finally thawing everything resets to
+			// None
+			test_thaw(DummyFreezeReason::Governance);
+			assert_eq!(AssetsFreezer::frozen_balance(ASSET_ID, &WHO), Some(3u64));
+			test_thaw(DummyFreezeReason::Staking);
+			assert_eq!(AssetsFreezer::frozen_balance(ASSET_ID, &WHO), None);
+		});
+	}
+
+	#[test]
+	fn died_works() {
+		new_test_ext(|| {
+			test_set_freeze(DummyFreezeReason::Governance, 1);
+			AssetsFreezer::died(ASSET_ID, &WHO);
+			assert!(FrozenBalances::<Test>::get(ASSET_ID, WHO).is_none());
+			assert!(Freezes::<Test>::get(ASSET_ID, WHO).is_empty());
+		});
+	}
+}
+
+mod impl_inspect_freeze {
+	use super::*;
+
+	#[test]
+	fn balance_frozen_works() {
+		new_test_ext(|| {
+			assert_eq!(
+				AssetsFreezer::balance_frozen(ASSET_ID, &DummyFreezeReason::Governance, &WHO),
+				0u64
+			);
+			test_set_freeze(DummyFreezeReason::Governance, 1);
+			assert_eq!(
+				AssetsFreezer::balance_frozen(ASSET_ID, &DummyFreezeReason::Governance, &WHO),
+				1u64
+			);
+			test_set_freeze(DummyFreezeReason::Staking, 3);
+			assert_eq!(
+				AssetsFreezer::balance_frozen(ASSET_ID, &DummyFreezeReason::Staking, &WHO),
+				3u64
+			);
+			test_set_freeze(DummyFreezeReason::Staking, 2);
+			assert_eq!(
+				AssetsFreezer::balance_frozen(ASSET_ID, &DummyFreezeReason::Staking, &WHO),
+				2u64
+			);
+			// also test thawing works to reduce a balance, and finally thawing everything resets to
+			// 0
+			test_thaw(DummyFreezeReason::Governance);
+			assert_eq!(
+				AssetsFreezer::balance_frozen(ASSET_ID, &DummyFreezeReason::Governance, &WHO),
+				0u64
+			);
+			test_thaw(DummyFreezeReason::Staking);
+			assert_eq!(
+				AssetsFreezer::balance_frozen(ASSET_ID, &DummyFreezeReason::Staking, &WHO),
+				0u64
+			);
+		});
+	}
+
+	/// This tests it's not possible to freeze once the freezes [`BoundedVec`] is full. This is,
+	/// the lenght of the vec is equal to [`Config::MaxFreezes`].
+	/// This test assumes a mock configuration where this parameter is set to `2`.
+	#[test]
+	fn can_freeze_works() {
+		new_test_ext(|| {
+			test_set_freeze(DummyFreezeReason::Governance, 1);
+			assert!(AssetsFreezer::can_freeze(ASSET_ID, &DummyFreezeReason::Staking, &WHO));
+			test_set_freeze(DummyFreezeReason::Staking, 1);
+			assert!(!AssetsFreezer::can_freeze(ASSET_ID, &DummyFreezeReason::Other, &WHO));
+		});
+	}
+}
+
+mod impl_mutate_freeze {
+	use super::*;
+
+	#[test]
+	fn set_freeze_works() {
+		new_test_ext(|| {
+			assert_eq!(
+				Assets::reducible_balance(
+					ASSET_ID,
+					&WHO,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				),
+				99
+			);
+			assert_ok!(AssetsFreezer::set_freeze(
+				ASSET_ID,
+				&DummyFreezeReason::Governance,
+				&WHO,
+				10
+			));
+			assert_eq!(
+				Assets::reducible_balance(
+					ASSET_ID,
+					&WHO,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				),
+				89
+			);
+			System::assert_last_event(
+				Event::<Test>::Frozen { asset_id: ASSET_ID, who: WHO, amount: 10 }.into(),
+			);
+			assert_ok!(AssetsFreezer::set_freeze(
+				ASSET_ID,
+				&DummyFreezeReason::Governance,
+				&WHO,
+				8
+			));
+			assert_eq!(
+				Assets::reducible_balance(
+					ASSET_ID,
+					&WHO,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				),
+				91
+			);
+			System::assert_last_event(
+				Event::<Test>::Thawed { asset_id: ASSET_ID, who: WHO, amount: 2 }.into(),
+			);
+		});
+	}
+
+	#[test]
+	fn extend_freeze_works() {
+		new_test_ext(|| {
+			assert_ok!(AssetsFreezer::set_freeze(
+				ASSET_ID,
+				&DummyFreezeReason::Governance,
+				&WHO,
+				10
+			));
+			assert_storage_noop!(assert_ok!(AssetsFreezer::extend_freeze(
+				ASSET_ID,
+				&DummyFreezeReason::Governance,
+				&WHO,
+				8
+			)));
+			System::assert_last_event(
+				Event::<Test>::Frozen { asset_id: ASSET_ID, who: WHO, amount: 10 }.into(),
+			);
+			assert_eq!(
+				Assets::reducible_balance(
+					ASSET_ID,
+					&WHO,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				),
+				89
+			);
+			assert_ok!(AssetsFreezer::extend_freeze(
+				ASSET_ID,
+				&DummyFreezeReason::Governance,
+				&WHO,
+				11
+			));
+			System::assert_last_event(
+				Event::<Test>::Frozen { asset_id: ASSET_ID, who: WHO, amount: 1 }.into(),
+			);
+			assert_eq!(
+				Assets::reducible_balance(
+					ASSET_ID,
+					&WHO,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				),
+				88
+			);
+		});
+	}
+
+	#[test]
+	fn thaw_works() {
+		new_test_ext(|| {
+			assert_ok!(AssetsFreezer::set_freeze(
+				ASSET_ID,
+				&DummyFreezeReason::Governance,
+				&WHO,
+				10
+			));
+			System::assert_has_event(
+				Event::<Test>::Frozen { asset_id: ASSET_ID, who: WHO, amount: 10 }.into(),
+			);
+			assert_eq!(
+				Assets::reducible_balance(
+					ASSET_ID,
+					&WHO,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				),
+				89
+			);
+			assert_ok!(AssetsFreezer::thaw(ASSET_ID, &DummyFreezeReason::Governance, &WHO));
+			System::assert_has_event(
+				Event::<Test>::Thawed { asset_id: ASSET_ID, who: WHO, amount: 10 }.into(),
+			);
+			assert_eq!(
+				Assets::reducible_balance(
+					ASSET_ID,
+					&WHO,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				),
+				99
+			);
+		});
+	}
+}
+
+mod with_pallet_assets {
+	use frame_support::assert_noop;
+
+	use super::*;
+
+	#[test]
+	fn frozen_balance_affects_balance_transferring() {
+		new_test_ext(|| {
+			assert_ok!(AssetsFreezer::set_freeze(
+				ASSET_ID,
+				&DummyFreezeReason::Governance,
+				&WHO,
+				20
+			));
+			assert_noop!(
+				Assets::transfer(RuntimeOrigin::signed(WHO), Compact(ASSET_ID), 2, 80),
+				pallet_assets::Error::<Test>::BalanceLow,
+			);
+			assert_ok!(Assets::transfer(RuntimeOrigin::signed(WHO), Compact(ASSET_ID), 2, 79));
+		});
+	}
+}
diff --git a/substrate/frame/balances/src/lib.rs b/substrate/frame/balances/src/lib.rs
index 4935323b3aa..d01884293c0 100644
--- a/substrate/frame/balances/src/lib.rs
+++ b/substrate/frame/balances/src/lib.rs
@@ -158,6 +158,7 @@ use frame_support::{
 		tokens::{
 			fungible, BalanceStatus as Status, DepositConsequence,
 			Fortitude::{self, Force, Polite},
+			IdAmount,
 			Preservation::{Expendable, Preserve, Protect},
 			WithdrawConsequence,
 		},
@@ -177,8 +178,7 @@ use sp_runtime::{
 };
 use sp_std::{cmp, fmt::Debug, mem, prelude::*, result};
 pub use types::{
-	AccountData, AdjustmentDirection, BalanceLock, DustCleaner, ExtraFlags, IdAmount, Reasons,
-	ReserveData,
+	AccountData, AdjustmentDirection, BalanceLock, DustCleaner, ExtraFlags, Reasons, ReserveData,
 };
 pub use weights::WeightInfo;
 
diff --git a/substrate/frame/balances/src/types.rs b/substrate/frame/balances/src/types.rs
index 3e36a83575c..917b7507d7c 100644
--- a/substrate/frame/balances/src/types.rs
+++ b/substrate/frame/balances/src/types.rs
@@ -78,15 +78,6 @@ pub struct ReserveData<ReserveIdentifier, Balance> {
 	pub amount: Balance,
 }
 
-/// An identifier and balance.
-#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
-pub struct IdAmount<Id, Balance> {
-	/// An identifier for this item.
-	pub id: Id,
-	/// Some amount for this item.
-	pub amount: Balance,
-}
-
 /// All balance information for an account.
 #[derive(Encode, Decode, Clone, PartialEq, Eq, Default, RuntimeDebug, MaxEncodedLen, TypeInfo)]
 pub struct AccountData<Balance> {
diff --git a/substrate/frame/support/src/traits/tokens.rs b/substrate/frame/support/src/traits/tokens.rs
index 8842b205801..138703cf1d1 100644
--- a/substrate/frame/support/src/traits/tokens.rs
+++ b/substrate/frame/support/src/traits/tokens.rs
@@ -30,8 +30,8 @@ pub use imbalance::Imbalance;
 pub mod pay;
 pub use misc::{
 	AssetId, Balance, BalanceStatus, ConversionFromAssetBalance, ConversionToAssetBalance,
-	ConvertRank, DepositConsequence, ExistenceRequirement, Fortitude, GetSalary, Locker, Precision,
-	Preservation, Provenance, Restriction, UnityAssetBalanceConversion, UnityOrOuterConversion,
-	WithdrawConsequence, WithdrawReasons,
+	ConvertRank, DepositConsequence, ExistenceRequirement, Fortitude, GetSalary, IdAmount, Locker,
+	Precision, Preservation, Provenance, Restriction, UnityAssetBalanceConversion,
+	UnityOrOuterConversion, WithdrawConsequence, WithdrawReasons,
 };
 pub use pay::{Pay, PayFromAccount, PaymentStatus};
diff --git a/substrate/frame/support/src/traits/tokens/misc.rs b/substrate/frame/support/src/traits/tokens/misc.rs
index 424acb1d550..e1ff1e058ae 100644
--- a/substrate/frame/support/src/traits/tokens/misc.rs
+++ b/substrate/frame/support/src/traits/tokens/misc.rs
@@ -17,7 +17,7 @@
 
 //! Miscellaneous types.
 
-use crate::traits::Contains;
+use crate::{traits::Contains, TypeInfo};
 use codec::{Decode, Encode, FullCodec, MaxEncodedLen};
 use sp_arithmetic::traits::{AtLeast32BitUnsigned, Zero};
 use sp_core::RuntimeDebug;
@@ -357,3 +357,12 @@ impl<A, R, B, C: Convert<R, B>> GetSalary<R, A, B> for ConvertRank<C> {
 		C::convert(rank)
 	}
 }
+
+/// An identifier and balance.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub struct IdAmount<Id, Balance> {
+	/// An identifier for this item.
+	pub id: Id,
+	/// Some amount for this item.
+	pub amount: Balance,
+}
diff --git a/umbrella/Cargo.toml b/umbrella/Cargo.toml
index d790b4f5949..93af28a7ddd 100644
--- a/umbrella/Cargo.toml
+++ b/umbrella/Cargo.toml
@@ -68,6 +68,7 @@ std = [
 	"pallet-asset-conversion?/std",
 	"pallet-asset-rate?/std",
 	"pallet-asset-tx-payment?/std",
+	"pallet-assets-freezer?/std",
 	"pallet-assets?/std",
 	"pallet-atomic-swap?/std",
 	"pallet-aura?/std",
@@ -263,6 +264,7 @@ runtime-benchmarks = [
 	"pallet-asset-conversion?/runtime-benchmarks",
 	"pallet-asset-rate?/runtime-benchmarks",
 	"pallet-asset-tx-payment?/runtime-benchmarks",
+	"pallet-assets-freezer?/runtime-benchmarks",
 	"pallet-assets?/runtime-benchmarks",
 	"pallet-babe?/runtime-benchmarks",
 	"pallet-bags-list?/runtime-benchmarks",
@@ -385,6 +387,7 @@ try-runtime = [
 	"pallet-asset-conversion?/try-runtime",
 	"pallet-asset-rate?/try-runtime",
 	"pallet-asset-tx-payment?/try-runtime",
+	"pallet-assets-freezer?/try-runtime",
 	"pallet-assets?/try-runtime",
 	"pallet-atomic-swap?/try-runtime",
 	"pallet-aura?/try-runtime",
@@ -536,7 +539,7 @@ with-tracing = [
 	"sp-tracing?/with-tracing",
 	"sp-tracing?/with-tracing",
 ]
-runtime = ["assets-common", "binary-merkle-tree", "bp-asset-hub-rococo", "bp-asset-hub-westend", "bp-bridge-hub-cumulus", "bp-bridge-hub-kusama", "bp-bridge-hub-polkadot", "bp-bridge-hub-rococo", "bp-bridge-hub-westend", "bp-header-chain", "bp-kusama", "bp-messages", "bp-parachains", "bp-polkadot", "bp-polkadot-bulletin", "bp-polkadot-core", "bp-relayers", "bp-rococo", "bp-runtime", "bp-test-utils", "bp-westend", "bp-xcm-bridge-hub", "bp-xcm-bridge-hub-router", "bridge-hub-common", "bridge-runtime-common", "cumulus-pallet-aura-ext", "cumulus-pallet-dmp-queue", "cumulus-pallet-parachain-system", "cumulus-pallet-parachain-system-proc-macro", "cumulus-pallet-session-benchmarking", "cumulus-pallet-solo-to-para", "cumulus-pallet-xcm", "cumulus-pallet-xcmp-queue", "cumulus-ping", "cumulus-primitives-aura", "cumulus-primitives-core", "cumulus-primitives-parachain-inherent", "cumulus-primitives-proof-size-hostfunction", "cumulus-primitives-storage-weight-reclaim", "cumulus-primitives-timestamp", "cumulus-primitives-utility", "frame-benchmarking", "frame-benchmarking-pallet-pov", "frame-election-provider-solution-type", "frame-election-provider-support", "frame-executive", "frame-metadata-hash-extension", "frame-support", "frame-support-procedural", "frame-support-procedural-tools-derive", "frame-system", "frame-system-benchmarking", "frame-system-rpc-runtime-api", "frame-try-runtime", "pallet-alliance", "pallet-asset-conversion", "pallet-asset-conversion-ops", "pallet-asset-conversion-tx-payment", "pallet-asset-rate", "pallet-asset-tx-payment", "pallet-assets", "pallet-atomic-swap", "pallet-aura", "pallet-authority-discovery", "pallet-authorship", "pallet-babe", "pallet-bags-list", "pallet-balances", "pallet-beefy", "pallet-beefy-mmr", "pallet-bounties", "pallet-bridge-grandpa", "pallet-bridge-messages", "pallet-bridge-parachains", "pallet-bridge-relayers", "pallet-broker", "pallet-child-bounties", "pallet-collator-selection", "pallet-collective", "pallet-collective-content", "pallet-contracts", "pallet-contracts-proc-macro", "pallet-contracts-uapi", "pallet-conviction-voting", "pallet-core-fellowship", "pallet-delegated-staking", "pallet-democracy", "pallet-dev-mode", "pallet-election-provider-multi-phase", "pallet-election-provider-support-benchmarking", "pallet-elections-phragmen", "pallet-fast-unstake", "pallet-glutton", "pallet-grandpa", "pallet-identity", "pallet-im-online", "pallet-indices", "pallet-insecure-randomness-collective-flip", "pallet-lottery", "pallet-membership", "pallet-message-queue", "pallet-migrations", "pallet-mixnet", "pallet-mmr", "pallet-multisig", "pallet-nft-fractionalization", "pallet-nfts", "pallet-nfts-runtime-api", "pallet-nis", "pallet-node-authorization", "pallet-nomination-pools", "pallet-nomination-pools-benchmarking", "pallet-nomination-pools-runtime-api", "pallet-offences", "pallet-offences-benchmarking", "pallet-paged-list", "pallet-parameters", "pallet-preimage", "pallet-proxy", "pallet-ranked-collective", "pallet-recovery", "pallet-referenda", "pallet-remark", "pallet-root-offences", "pallet-root-testing", "pallet-safe-mode", "pallet-salary", "pallet-scheduler", "pallet-scored-pool", "pallet-session", "pallet-session-benchmarking", "pallet-skip-feeless-payment", "pallet-society", "pallet-staking", "pallet-staking-reward-curve", "pallet-staking-reward-fn", "pallet-staking-runtime-api", "pallet-state-trie-migration", "pallet-statement", "pallet-sudo", "pallet-timestamp", "pallet-tips", "pallet-transaction-payment", "pallet-transaction-payment-rpc-runtime-api", "pallet-transaction-storage", "pallet-treasury", "pallet-tx-pause", "pallet-uniques", "pallet-utility", "pallet-vesting", "pallet-whitelist", "pallet-xcm", "pallet-xcm-benchmarks", "pallet-xcm-bridge-hub", "pallet-xcm-bridge-hub-router", "parachains-common", "polkadot-core-primitives", "polkadot-parachain-primitives", "polkadot-primitives", "polkadot-runtime-common", "polkadot-runtime-metrics", "polkadot-runtime-parachains", "polkadot-sdk-frame", "rococo-runtime-constants", "sc-chain-spec-derive", "sc-tracing-proc-macro", "slot-range-helper", "snowbridge-beacon-primitives", "snowbridge-core", "snowbridge-ethereum", "snowbridge-outbound-queue-merkle-tree", "snowbridge-outbound-queue-runtime-api", "snowbridge-pallet-ethereum-client", "snowbridge-pallet-ethereum-client-fixtures", "snowbridge-pallet-inbound-queue", "snowbridge-pallet-inbound-queue-fixtures", "snowbridge-pallet-outbound-queue", "snowbridge-pallet-system", "snowbridge-router-primitives", "snowbridge-runtime-common", "snowbridge-system-runtime-api", "sp-api", "sp-api-proc-macro", "sp-application-crypto", "sp-arithmetic", "sp-authority-discovery", "sp-block-builder", "sp-consensus-aura", "sp-consensus-babe", "sp-consensus-beefy", "sp-consensus-grandpa", "sp-consensus-pow", "sp-consensus-slots", "sp-core", "sp-crypto-ec-utils", "sp-crypto-hashing", "sp-crypto-hashing-proc-macro", "sp-debug-derive", "sp-externalities", "sp-genesis-builder", "sp-inherents", "sp-io", "sp-keyring", "sp-keystore", "sp-metadata-ir", "sp-mixnet", "sp-mmr-primitives", "sp-npos-elections", "sp-offchain", "sp-runtime", "sp-runtime-interface", "sp-runtime-interface-proc-macro", "sp-session", "sp-staking", "sp-state-machine", "sp-statement-store", "sp-std", "sp-storage", "sp-timestamp", "sp-tracing", "sp-transaction-pool", "sp-transaction-storage-proof", "sp-trie", "sp-version", "sp-version-proc-macro", "sp-wasm-interface", "sp-weights", "staging-parachain-info", "staging-xcm", "staging-xcm-builder", "staging-xcm-executor", "substrate-bip39", "testnet-parachains-constants", "tracing-gum-proc-macro", "westend-runtime-constants", "xcm-fee-payment-runtime-api", "xcm-procedural"]
+runtime = ["assets-common", "binary-merkle-tree", "bp-asset-hub-rococo", "bp-asset-hub-westend", "bp-bridge-hub-cumulus", "bp-bridge-hub-kusama", "bp-bridge-hub-polkadot", "bp-bridge-hub-rococo", "bp-bridge-hub-westend", "bp-header-chain", "bp-kusama", "bp-messages", "bp-parachains", "bp-polkadot", "bp-polkadot-bulletin", "bp-polkadot-core", "bp-relayers", "bp-rococo", "bp-runtime", "bp-test-utils", "bp-westend", "bp-xcm-bridge-hub", "bp-xcm-bridge-hub-router", "bridge-hub-common", "bridge-runtime-common", "cumulus-pallet-aura-ext", "cumulus-pallet-dmp-queue", "cumulus-pallet-parachain-system", "cumulus-pallet-parachain-system-proc-macro", "cumulus-pallet-session-benchmarking", "cumulus-pallet-solo-to-para", "cumulus-pallet-xcm", "cumulus-pallet-xcmp-queue", "cumulus-ping", "cumulus-primitives-aura", "cumulus-primitives-core", "cumulus-primitives-parachain-inherent", "cumulus-primitives-proof-size-hostfunction", "cumulus-primitives-storage-weight-reclaim", "cumulus-primitives-timestamp", "cumulus-primitives-utility", "frame-benchmarking", "frame-benchmarking-pallet-pov", "frame-election-provider-solution-type", "frame-election-provider-support", "frame-executive", "frame-metadata-hash-extension", "frame-support", "frame-support-procedural", "frame-support-procedural-tools-derive", "frame-system", "frame-system-benchmarking", "frame-system-rpc-runtime-api", "frame-try-runtime", "pallet-alliance", "pallet-asset-conversion", "pallet-asset-conversion-ops", "pallet-asset-conversion-tx-payment", "pallet-asset-rate", "pallet-asset-tx-payment", "pallet-assets", "pallet-assets-freezer", "pallet-atomic-swap", "pallet-aura", "pallet-authority-discovery", "pallet-authorship", "pallet-babe", "pallet-bags-list", "pallet-balances", "pallet-beefy", "pallet-beefy-mmr", "pallet-bounties", "pallet-bridge-grandpa", "pallet-bridge-messages", "pallet-bridge-parachains", "pallet-bridge-relayers", "pallet-broker", "pallet-child-bounties", "pallet-collator-selection", "pallet-collective", "pallet-collective-content", "pallet-contracts", "pallet-contracts-proc-macro", "pallet-contracts-uapi", "pallet-conviction-voting", "pallet-core-fellowship", "pallet-delegated-staking", "pallet-democracy", "pallet-dev-mode", "pallet-election-provider-multi-phase", "pallet-election-provider-support-benchmarking", "pallet-elections-phragmen", "pallet-fast-unstake", "pallet-glutton", "pallet-grandpa", "pallet-identity", "pallet-im-online", "pallet-indices", "pallet-insecure-randomness-collective-flip", "pallet-lottery", "pallet-membership", "pallet-message-queue", "pallet-migrations", "pallet-mixnet", "pallet-mmr", "pallet-multisig", "pallet-nft-fractionalization", "pallet-nfts", "pallet-nfts-runtime-api", "pallet-nis", "pallet-node-authorization", "pallet-nomination-pools", "pallet-nomination-pools-benchmarking", "pallet-nomination-pools-runtime-api", "pallet-offences", "pallet-offences-benchmarking", "pallet-paged-list", "pallet-parameters", "pallet-preimage", "pallet-proxy", "pallet-ranked-collective", "pallet-recovery", "pallet-referenda", "pallet-remark", "pallet-root-offences", "pallet-root-testing", "pallet-safe-mode", "pallet-salary", "pallet-scheduler", "pallet-scored-pool", "pallet-session", "pallet-session-benchmarking", "pallet-skip-feeless-payment", "pallet-society", "pallet-staking", "pallet-staking-reward-curve", "pallet-staking-reward-fn", "pallet-staking-runtime-api", "pallet-state-trie-migration", "pallet-statement", "pallet-sudo", "pallet-timestamp", "pallet-tips", "pallet-transaction-payment", "pallet-transaction-payment-rpc-runtime-api", "pallet-transaction-storage", "pallet-treasury", "pallet-tx-pause", "pallet-uniques", "pallet-utility", "pallet-vesting", "pallet-whitelist", "pallet-xcm", "pallet-xcm-benchmarks", "pallet-xcm-bridge-hub", "pallet-xcm-bridge-hub-router", "parachains-common", "polkadot-core-primitives", "polkadot-parachain-primitives", "polkadot-primitives", "polkadot-runtime-common", "polkadot-runtime-metrics", "polkadot-runtime-parachains", "polkadot-sdk-frame", "rococo-runtime-constants", "sc-chain-spec-derive", "sc-tracing-proc-macro", "slot-range-helper", "snowbridge-beacon-primitives", "snowbridge-core", "snowbridge-ethereum", "snowbridge-outbound-queue-merkle-tree", "snowbridge-outbound-queue-runtime-api", "snowbridge-pallet-ethereum-client", "snowbridge-pallet-ethereum-client-fixtures", "snowbridge-pallet-inbound-queue", "snowbridge-pallet-inbound-queue-fixtures", "snowbridge-pallet-outbound-queue", "snowbridge-pallet-system", "snowbridge-router-primitives", "snowbridge-runtime-common", "snowbridge-system-runtime-api", "sp-api", "sp-api-proc-macro", "sp-application-crypto", "sp-arithmetic", "sp-authority-discovery", "sp-block-builder", "sp-consensus-aura", "sp-consensus-babe", "sp-consensus-beefy", "sp-consensus-grandpa", "sp-consensus-pow", "sp-consensus-slots", "sp-core", "sp-crypto-ec-utils", "sp-crypto-hashing", "sp-crypto-hashing-proc-macro", "sp-debug-derive", "sp-externalities", "sp-genesis-builder", "sp-inherents", "sp-io", "sp-keyring", "sp-keystore", "sp-metadata-ir", "sp-mixnet", "sp-mmr-primitives", "sp-npos-elections", "sp-offchain", "sp-runtime", "sp-runtime-interface", "sp-runtime-interface-proc-macro", "sp-session", "sp-staking", "sp-state-machine", "sp-statement-store", "sp-std", "sp-storage", "sp-timestamp", "sp-tracing", "sp-transaction-pool", "sp-transaction-storage-proof", "sp-trie", "sp-version", "sp-version-proc-macro", "sp-wasm-interface", "sp-weights", "staging-parachain-info", "staging-xcm", "staging-xcm-builder", "staging-xcm-executor", "substrate-bip39", "testnet-parachains-constants", "tracing-gum-proc-macro", "westend-runtime-constants", "xcm-fee-payment-runtime-api", "xcm-procedural"]
 node = ["asset-test-utils", "bridge-hub-test-utils", "cumulus-client-cli", "cumulus-client-collator", "cumulus-client-consensus-aura", "cumulus-client-consensus-common", "cumulus-client-consensus-proposer", "cumulus-client-consensus-relay-chain", "cumulus-client-network", "cumulus-client-parachain-inherent", "cumulus-client-pov-recovery", "cumulus-client-service", "cumulus-relay-chain-inprocess-interface", "cumulus-relay-chain-interface", "cumulus-relay-chain-minimal-node", "cumulus-relay-chain-rpc-interface", "cumulus-test-relay-sproof-builder", "emulated-integration-tests-common", "fork-tree", "frame-benchmarking-cli", "frame-remote-externalities", "frame-support-procedural-tools", "generate-bags", "mmr-gadget", "mmr-rpc", "pallet-contracts-mock-network", "pallet-transaction-payment-rpc", "parachains-runtimes-test-utils", "polkadot-approval-distribution", "polkadot-availability-bitfield-distribution", "polkadot-availability-distribution", "polkadot-availability-recovery", "polkadot-cli", "polkadot-collator-protocol", "polkadot-dispute-distribution", "polkadot-erasure-coding", "polkadot-gossip-support", "polkadot-network-bridge", "polkadot-node-collation-generation", "polkadot-node-core-approval-voting", "polkadot-node-core-av-store", "polkadot-node-core-backing", "polkadot-node-core-bitfield-signing", "polkadot-node-core-candidate-validation", "polkadot-node-core-chain-api", "polkadot-node-core-chain-selection", "polkadot-node-core-dispute-coordinator", "polkadot-node-core-parachains-inherent", "polkadot-node-core-prospective-parachains", "polkadot-node-core-provisioner", "polkadot-node-core-pvf", "polkadot-node-core-pvf-checker", "polkadot-node-core-pvf-common", "polkadot-node-core-pvf-execute-worker", "polkadot-node-core-pvf-prepare-worker", "polkadot-node-core-runtime-api", "polkadot-node-jaeger", "polkadot-node-metrics", "polkadot-node-network-protocol", "polkadot-node-primitives", "polkadot-node-subsystem", "polkadot-node-subsystem-types", "polkadot-node-subsystem-util", "polkadot-overseer", "polkadot-rpc", "polkadot-service", "polkadot-statement-distribution", "polkadot-statement-table", "sc-allocator", "sc-authority-discovery", "sc-basic-authorship", "sc-block-builder", "sc-chain-spec", "sc-cli", "sc-client-api", "sc-client-db", "sc-consensus", "sc-consensus-aura", "sc-consensus-babe", "sc-consensus-babe-rpc", "sc-consensus-beefy", "sc-consensus-beefy-rpc", "sc-consensus-epochs", "sc-consensus-grandpa", "sc-consensus-grandpa-rpc", "sc-consensus-manual-seal", "sc-consensus-pow", "sc-consensus-slots", "sc-executor", "sc-executor-common", "sc-executor-polkavm", "sc-executor-wasmtime", "sc-informant", "sc-keystore", "sc-mixnet", "sc-network", "sc-network-common", "sc-network-gossip", "sc-network-light", "sc-network-statement", "sc-network-sync", "sc-network-transactions", "sc-network-types", "sc-offchain", "sc-proposer-metrics", "sc-rpc", "sc-rpc-api", "sc-rpc-server", "sc-rpc-spec-v2", "sc-service", "sc-state-db", "sc-statement-store", "sc-storage-monitor", "sc-sync-state-rpc", "sc-sysinfo", "sc-telemetry", "sc-tracing", "sc-transaction-pool", "sc-transaction-pool-api", "sc-utils", "snowbridge-runtime-test-common", "sp-blockchain", "sp-consensus", "sp-core-hashing", "sp-core-hashing-proc-macro", "sp-database", "sp-maybe-compressed-blob", "sp-panic-handler", "sp-rpc", "staging-chain-spec-builder", "staging-node-inspect", "staging-tracking-allocator", "std", "subkey", "substrate-build-script-utils", "substrate-frame-rpc-support", "substrate-frame-rpc-system", "substrate-prometheus-endpoint", "substrate-rpc-client", "substrate-state-trie-migration-rpc", "substrate-wasm-builder", "tracing-gum", "xcm-emulator", "xcm-simulator"]
 tuples-96 = [
 	"frame-support-procedural?/tuples-96",
@@ -854,6 +857,11 @@ path = "../substrate/frame/assets"
 default-features = false
 optional = true
 
+[dependencies.pallet-assets-freezer]
+path = "../substrate/frame/assets-freezer"
+default-features = false
+optional = true
+
 [dependencies.pallet-atomic-swap]
 path = "../substrate/frame/atomic-swap"
 default-features = false
diff --git a/umbrella/src/lib.rs b/umbrella/src/lib.rs
index 78b34ba179b..87fcd4214db 100644
--- a/umbrella/src/lib.rs
+++ b/umbrella/src/lib.rs
@@ -360,6 +360,10 @@ pub use pallet_asset_tx_payment;
 #[cfg(feature = "pallet-assets")]
 pub use pallet_assets;
 
+/// Provides freezing features to `pallet-assets`.
+#[cfg(feature = "pallet-assets-freezer")]
+pub use pallet_assets_freezer;
+
 /// FRAME atomic swap pallet.
 #[cfg(feature = "pallet-atomic-swap")]
 pub use pallet_atomic_swap;
-- 
GitLab