diff --git a/Cargo.lock b/Cargo.lock
index e793163bb..27541d2ec 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5495,13 +5495,16 @@ dependencies = [
  "acala-primitives",
  "frame-support",
  "frame-system",
+ "log",
  "module-dex",
  "module-support",
  "nutsfinance-stable-asset",
  "orml-tokens",
  "orml-traits",
+ "orml-utilities",
  "pallet-balances",
  "parity-scale-codec",
+ "parking_lot 0.12.1",
  "scale-info",
  "serde",
  "sp-core",
diff --git a/modules/aggregated-dex/Cargo.toml b/modules/aggregated-dex/Cargo.toml
index 3ab934180..9d65bf489 100644
--- a/modules/aggregated-dex/Cargo.toml
+++ b/modules/aggregated-dex/Cargo.toml
@@ -8,36 +8,45 @@ edition = "2021"
 serde = { version = "1.0.136", optional = true }
 codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["max-encoded-len"] }
 scale-info = { version = "2.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+
+sp-io = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26", default-features = false }
 sp-core = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26", default-features = false }
 sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26", default-features = false }
+sp-std = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26", default-features = false }
 frame-support = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26", default-features = false }
 frame-system = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26", default-features = false }
-sp-std = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26", default-features = false }
-orml-traits = { path = "../../orml/traits", default-features = false }
-support = { package = "module-support", path = "../support", default-features = false }
-primitives = { package = "acala-primitives", path = "../../primitives", default-features = false }
-nutsfinance-stable-asset = { path = "../../ecosystem-modules/stable-asset/lib/stable-asset", version = "0.1.0", default-features = false }
+
 module-dex = { package = "module-dex", path = "../dex", default-features = false }
+primitives = { package = "acala-primitives", path = "../../primitives", default-features = false }
+support = { package = "module-support", path = "../support", default-features = false }
+
 orml-tokens = { path = "../../orml/tokens", default-features = false }
+orml-traits = { path = "../../orml/traits", default-features = false }
+orml-utilities = { path = "../../orml/utilities", default-features = false }
+
+nutsfinance-stable-asset = { path = "../../ecosystem-modules/stable-asset/lib/stable-asset", version = "0.1.0", default-features = false }
 
 [dev-dependencies]
-orml-tokens = { path = "../../orml/tokens" }
-sp-core = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26" }
-sp-io = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26" }
 pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26" }
+parking_lot = { version = "0.12.0" }
 
 [features]
 default = ["std"]
 std = [
 	"serde",
+	"log/std",
 	"codec/std",
 	"scale-info/std",
+	"sp-io/std",
+	"sp-core/std",
 	"sp-runtime/std",
+	"sp-std/std",
 	"frame-support/std",
 	"frame-system/std",
-	"sp-std/std",
 	"orml-traits/std",
 	"orml-tokens/std",
+	"orml-utilities/std",
 	"support/std",
 	"primitives/std",
 	"nutsfinance-stable-asset/std",
diff --git a/modules/aggregated-dex/src/lib.rs b/modules/aggregated-dex/src/lib.rs
index 5cfed06e8..12e36752c 100644
--- a/modules/aggregated-dex/src/lib.rs
+++ b/modules/aggregated-dex/src/lib.rs
@@ -22,12 +22,25 @@
 #![allow(clippy::unused_unit)]
 #![allow(clippy::type_complexity)]
 
-use frame_support::{pallet_prelude::*, transactional};
-use frame_system::pallet_prelude::*;
+use codec::Decode;
+use frame_support::{pallet_prelude::*, transactional, PalletId};
+use frame_system::{
+	offchain::{SendTransactionTypes, SubmitTransaction},
+	pallet_prelude::*,
+};
 use nutsfinance_stable_asset::traits::StableAsset as StableAssetT;
-use primitives::{Balance, CurrencyId};
-use sp_runtime::traits::{Convert, Zero};
-use sp_std::{marker::PhantomData, vec::Vec};
+use orml_utilities::OffchainErr;
+use primitives::{Balance, CurrencyId, TradingPair};
+use sp_runtime::offchain::storage_lock::StorageLockGuard;
+use sp_runtime::{
+	offchain::{
+		storage::StorageValueRef,
+		storage_lock::{StorageLock, Time},
+		Duration,
+	},
+	traits::{AccountIdConversion, Convert, Zero},
+};
+use sp_std::{collections::btree_map::BTreeMap, marker::PhantomData, prelude::*, vec::Vec};
 use support::{AggregatedSwapPath, DEXManager, RebasedStableAssetError, Swap, SwapLimit};
 
 mod mock;
@@ -35,8 +48,15 @@ mod tests;
 pub mod weights;
 
 pub use module::*;
+use module_dex::TradingPairStatuses;
 pub use weights::WeightInfo;
 
+pub const OFFCHAIN_WORKER_DATA: &[u8] = b"acala/dex-bot/data/";
+pub const OFFCHAIN_WORKER_LOCK: &[u8] = b"acala/dex-bot/lock/";
+pub const OFFCHAIN_WORKER_MAX_ITERATIONS: &[u8] = b"acala/dex-bot/max-iterations/";
+pub const LOCK_DURATION: u64 = 100;
+pub const DEFAULT_MAX_ITERATIONS: u32 = 100;
+
 pub type SwapPath = AggregatedSwapPath<CurrencyId>;
 
 #[frame_support::pallet]
@@ -44,7 +64,9 @@ pub mod module {
 	use super::*;
 
 	#[pallet::config]
-	pub trait Config: frame_system::Config {
+	pub trait Config: frame_system::Config + SendTransactionTypes<Call<Self>> + module_dex::Config {
+		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
+
 		/// DEX
 		type DEX: DEXManager<Self::AccountId, Balance, CurrencyId>;
 
@@ -68,6 +90,13 @@ pub mod module {
 		#[pallet::constant]
 		type SwapPathLimit: Get<u32>;
 
+		/// Treasury account participate in Rebalance swap.
+		#[pallet::constant]
+		type TreasuryPallet: Get<PalletId>;
+
+		#[pallet::constant]
+		type UnsignedPriority: Get<TransactionPriority>;
+
 		type WeightInfo: WeightInfo;
 	}
 
@@ -81,9 +110,29 @@ pub mod module {
 		InvalidTokenIndex,
 		/// The SwapPath is invalid.
 		InvalidSwapPath,
+		/// Rebalance swap info is invalid.
+		RebalanceSwapInfoInvalid,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(crate) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// Rebalance trading path and balance.
+		RebalanceTrading {
+			currency_id: CurrencyId,
+			supply_amount: Balance,
+			target_amount: Balance,
+			swap_path: Vec<SwapPath>,
+		},
+		/// Add rebalance info.
+		SetupRebalanceSwapInfo {
+			currency_id: CurrencyId,
+			supply_amount: Balance,
+			threshold: Balance,
+		},
 	}
 
-	/// The specific swap paths for  AggregatedSwap do aggreated_swap to swap TokenA to TokenB
+	/// The specific swap paths for  AggregatedSwap do aggregated_swap to swap TokenA to TokenB
 	///
 	/// AggregatedSwapPaths: Map: (token_a: CurrencyId, token_b: CurrencyId) => paths: Vec<SwapPath>
 	#[pallet::storage]
@@ -91,13 +140,42 @@ pub mod module {
 	pub type AggregatedSwapPaths<T: Config> =
 		StorageMap<_, Twox64Concat, (CurrencyId, CurrencyId), BoundedVec<SwapPath, T::SwapPathLimit>, OptionQuery>;
 
+	/// The specific rebalance swap paths doing aggregated_swap from TokenA to TokenA
+	///
+	/// AggregatedSwapPaths: Map: CurrencyId => paths: Vec<SwapPath>
+	#[pallet::storage]
+	#[pallet::getter(fn rebalance_swap_paths)]
+	pub type RebalanceSwapPaths<T: Config> =
+		StorageMap<_, Twox64Concat, CurrencyId, BoundedVec<SwapPath, T::SwapPathLimit>, OptionQuery>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn rebalance_supply_threshold)]
+	pub type RebalanceSupplyThreshold<T: Config> =
+		StorageMap<_, Twox64Concat, CurrencyId, (Balance, Balance), OptionQuery>;
+
 	#[pallet::pallet]
 	#[pallet::generate_store(pub(super) trait Store)]
 	#[pallet::without_storage_info]
 	pub struct Pallet<T>(_);
 
 	#[pallet::hooks]
-	impl<T: Config> Hooks<T::BlockNumber> for Pallet<T> {}
+	impl<T: Config> Hooks<T::BlockNumber> for Pallet<T> {
+		fn offchain_worker(now: T::BlockNumber) {
+			if let Err(e) = Self::_offchain_worker(now) {
+				log::info!(
+					target: "dex-bot",
+					"offchain worker: cannot run at {:?}: {:?}",
+					now, e,
+				);
+			} else {
+				log::debug!(
+					target: "dex-bot",
+					"offchain worker: start at block: {:?} already done!",
+					now,
+				);
+			}
+		}
+	}
 
 	#[pallet::call]
 	impl<T: Config> Pallet<T> {
@@ -177,10 +255,101 @@ pub mod module {
 
 			Ok(())
 		}
+
+		/// Update the rebalance swap paths for AggregatedSwap to swap TokenA to TokenA.
+		///
+		/// Requires `GovernanceOrigin`
+		///
+		/// Parameters:
+		/// - `updates`:  Vec<(CurrencyId, Option<Vec<SwapPath>>)>
+		#[pallet::weight(<T as Config>::WeightInfo::update_aggregated_swap_paths(updates.len() as u32))]
+		#[transactional]
+		pub fn update_rebalance_swap_paths(
+			origin: OriginFor<T>,
+			updates: Vec<(CurrencyId, Option<Vec<SwapPath>>)>,
+		) -> DispatchResult {
+			T::GovernanceOrigin::ensure_origin(origin)?;
+
+			for (key, maybe_paths) in updates {
+				if let Some(paths) = maybe_paths {
+					let paths: BoundedVec<SwapPath, T::SwapPathLimit> =
+						paths.try_into().map_err(|_| Error::<T>::InvalidSwapPath)?;
+					let (supply_currency_id, target_currency_id) = Self::check_swap_paths(&paths)?;
+					ensure!(
+						key == supply_currency_id && supply_currency_id == target_currency_id,
+						Error::<T>::InvalidSwapPath
+					);
+					RebalanceSwapPaths::<T>::insert(key, paths);
+				} else {
+					RebalanceSwapPaths::<T>::remove(key);
+				}
+			}
+
+			Ok(())
+		}
+
+		/// Update the rebalance swap information for specify token.
+		///
+		/// Parameters:
+		/// - `currency_id`: the token used for rebalance swap
+		/// - `supply_amount`: the supply amount of `currency_id` used for rebalance swap
+		/// - `threshold`: the target amount of `currency_id` used for rebalance swap
+		#[pallet::weight(<T as Config>::WeightInfo::set_rebalance_swap_info())]
+		#[transactional]
+		pub fn set_rebalance_swap_info(
+			origin: OriginFor<T>,
+			currency_id: CurrencyId,
+			#[pallet::compact] supply_amount: Balance,
+			#[pallet::compact] threshold: Balance,
+		) -> DispatchResult {
+			T::GovernanceOrigin::ensure_origin(origin)?;
+			Self::do_set_rebalance_swap_info(currency_id, supply_amount, threshold)
+		}
+
+		/// Force execution rebalance swap by offchain worker.
+		///
+		/// Parameters:
+		/// - `currency_id`: the token used for rebalance swap
+		/// - `swap_path`: the aggregated swap path used for rebalance swap
+		#[pallet::weight(<T as Config>::WeightInfo::force_rebalance_swap())]
+		#[transactional]
+		pub fn force_rebalance_swap(
+			origin: OriginFor<T>,
+			currency_id: CurrencyId,
+			swap_path: Vec<SwapPath>,
+		) -> DispatchResult {
+			ensure_none(origin)?;
+			Self::do_rebalance_swap(currency_id, swap_path)
+		}
+	}
+
+	#[pallet::validate_unsigned]
+	impl<T: Config> ValidateUnsigned for Pallet<T> {
+		type Call = Call<T>;
+		fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {
+			if let Call::force_rebalance_swap {
+				currency_id,
+				swap_path: _,
+			} = call
+			{
+				ValidTransaction::with_tag_prefix("DexBotOffchainWorker")
+					.priority(T::UnsignedPriority::get())
+					.and_provides((<frame_system::Pallet<T>>::block_number(), currency_id))
+					.longevity(64_u64)
+					.propagate(true)
+					.build()
+			} else {
+				InvalidTransaction::Call.into()
+			}
+		}
 	}
 }
 
 impl<T: Config> Pallet<T> {
+	fn treasury_account() -> T::AccountId {
+		T::TreasuryPallet::get().into_account_truncating()
+	}
+
 	fn check_swap_paths(paths: &[SwapPath]) -> sp_std::result::Result<(CurrencyId, CurrencyId), DispatchError> {
 		ensure!(!paths.is_empty(), Error::<T>::InvalidSwapPath);
 		let mut supply_currency_id: Option<CurrencyId> = None;
@@ -379,6 +548,192 @@ impl<T: Config> Pallet<T> {
 			}
 		}
 	}
+
+	fn do_set_rebalance_swap_info(
+		currency_id: CurrencyId,
+		supply_amount: Balance,
+		threshold: Balance,
+	) -> DispatchResult {
+		ensure!(threshold > supply_amount, Error::<T>::RebalanceSwapInfoInvalid);
+		RebalanceSupplyThreshold::<T>::try_mutate(currency_id, |maybe_supply_threshold| -> DispatchResult {
+			*maybe_supply_threshold = Some((supply_amount, threshold));
+			Ok(())
+		})?;
+		Self::deposit_event(Event::SetupRebalanceSwapInfo {
+			currency_id,
+			supply_amount,
+			threshold,
+		});
+		Ok(())
+	}
+
+	fn submit_rebalance_swap_tx(currency_id: CurrencyId, swap_path: Vec<SwapPath>) {
+		let call = Call::<T>::force_rebalance_swap { currency_id, swap_path };
+		if let Err(err) = SubmitTransaction::<T, Call<T>>::submit_unsigned_transaction(call.into()) {
+			log::info!(
+				target: "dex-bot",
+				"offchain worker: submit unsigned swap from currency:{:?}, failed: {:?}",
+				currency_id, err,
+			);
+		}
+	}
+
+	pub fn calculate_rebalance_paths(
+		// mut _finished: bool,
+		// mut iteration_count: u32,
+		max_iterations: u32,
+		// mut _last_currency_id: Option<CurrencyId>,
+		start_key: Option<Vec<u8>>,
+		mut guard: Option<&mut StorageLockGuard<Time>>,
+		f: impl Fn(CurrencyId, Vec<SwapPath>),
+	) -> Result<(bool, Option<CurrencyId>), OffchainErr> {
+		let mut finished = true;
+		let mut iteration_count = 0;
+		let mut last_currency_id: Option<CurrencyId> = None;
+
+		let mut trading_pair_values_map: BTreeMap<CurrencyId, Vec<CurrencyId>> = BTreeMap::new();
+		let mut first_currency: Option<CurrencyId> = None;
+		TradingPairStatuses::<T>::iter()
+			.filter(|(_, status)| status.enabled())
+			.for_each(|(pair, _)| {
+				trading_pair_values_map
+					.entry(pair.first())
+					.or_insert_with(Vec::<CurrencyId>::new)
+					.push(pair.second());
+				if first_currency.is_none() {
+					first_currency = Some(pair.first());
+				}
+			});
+		let mut iterator = trading_pair_values_map.iter();
+
+		// processing pure dex rebalance swap
+		#[allow(clippy::while_let_on_iterator)]
+		'outer: while let Some((currency_id, trading_tokens)) = iterator.next() {
+			// BTreeMap don't have `iter_from(key)`, use compare to ignore previous processed token.
+			match start_key.clone() {
+				Some(key) => {
+					let starter_key = CurrencyId::decode(&mut &*key).map_err(|_| OffchainErr::OffchainLock)?;
+					if *currency_id < starter_key {
+						continue;
+					}
+				}
+				None => {}
+			};
+
+			let len = trading_tokens.len();
+			if len < 2 {
+				continue;
+			}
+			// update last processing CurrencyId
+			last_currency_id = Some(*currency_id);
+			for i in 0..(len - 1) {
+				for j in (i + 1)..len {
+					iteration_count += 1;
+
+					if let Some(pair) = TradingPair::from_currency_ids(trading_tokens[i], trading_tokens[j]) {
+						if TradingPairStatuses::<T>::contains_key(&pair) {
+							let pair_status = TradingPairStatuses::<T>::get(&pair);
+							if pair_status.enabled() {
+								let first_path: Vec<CurrencyId> = vec![*currency_id, pair.first(), pair.second()];
+								let second_path: Vec<CurrencyId> = vec![pair.second(), *currency_id];
+								let swap_path = vec![SwapPath::Dex(first_path), SwapPath::Dex(second_path)];
+								// TODO: check swap_amount before submit unsigned tx?
+								f(*currency_id, swap_path);
+							}
+						}
+					}
+
+					// inner iterator consider as iterations too.
+					if iteration_count == max_iterations {
+						finished = false;
+						break 'outer;
+					}
+
+					// extend offchain worker lock
+					if let Some(ref mut guard) = guard {
+						guard.extend_lock().map_err(|_| OffchainErr::OffchainLock)?;
+					}
+				}
+			}
+		}
+
+		// processing aggregated dex rebalance swap
+		if iteration_count < max_iterations {
+			for (currency_id, swap_path) in RebalanceSwapPaths::<T>::iter() {
+				iteration_count += 1;
+
+				f(currency_id, swap_path.into_inner());
+
+				// inner iterator consider as iterations too.
+				if iteration_count == max_iterations {
+					finished = false;
+					break;
+				}
+
+				// extend offchain worker lock
+				if let Some(ref mut guard) = guard {
+					guard.extend_lock().map_err(|_| OffchainErr::OffchainLock)?;
+				}
+			}
+		}
+
+		Ok((finished, last_currency_id))
+	}
+
+	fn _offchain_worker(_now: T::BlockNumber) -> Result<(), OffchainErr> {
+		// acquire offchain worker lock
+		let lock_expiration = Duration::from_millis(LOCK_DURATION);
+		let mut lock = StorageLock::<'_, Time>::with_deadline(OFFCHAIN_WORKER_LOCK, lock_expiration);
+		let mut guard = lock.try_lock().map_err(|_| OffchainErr::OffchainLock)?;
+		// get the max iterations config
+		let max_iterations = StorageValueRef::persistent(OFFCHAIN_WORKER_MAX_ITERATIONS)
+			.get::<u32>()
+			.unwrap_or(Some(DEFAULT_MAX_ITERATIONS))
+			.unwrap_or(DEFAULT_MAX_ITERATIONS);
+		let mut to_be_continue = StorageValueRef::persistent(OFFCHAIN_WORKER_DATA);
+		let start_key = to_be_continue.get::<Vec<u8>>().unwrap_or_default();
+
+		let (finished, last_currency_id) =
+			Self::calculate_rebalance_paths(max_iterations, start_key, Some(&mut guard), |currency_id, swap_path| {
+				Self::submit_rebalance_swap_tx(currency_id, swap_path)
+			})?;
+
+		// if iteration for map storage finished, clear to be continue record
+		// otherwise, update to be continue record
+		if finished {
+			to_be_continue.clear();
+		} else {
+			match last_currency_id {
+				Some(last_currency_id) => to_be_continue.set(&last_currency_id.encode()),
+				None => to_be_continue.clear(),
+			}
+		}
+
+		// Consume the guard but **do not** unlock the underlying lock.
+		guard.forget();
+
+		Ok(())
+	}
+
+	/// Rebalance swap on path, the final output should be large than input.
+	fn do_rebalance_swap(currency_id: CurrencyId, swap_path: Vec<SwapPath>) -> DispatchResult {
+		if let Some((supply_amount, minimum_amount)) = RebalanceSupplyThreshold::<T>::get(&currency_id) {
+			let supply = SwapLimit::ExactSupply(supply_amount, 0);
+			if let Some((_, target_amount)) = Pallet::<T>::get_aggregated_swap_amount(&swap_path, supply) {
+				if target_amount > minimum_amount {
+					Pallet::<T>::do_aggregated_swap(&Self::treasury_account(), &swap_path, supply)?;
+
+					Self::deposit_event(Event::RebalanceTrading {
+						currency_id,
+						supply_amount,
+						target_amount,
+						swap_path,
+					});
+				}
+			}
+		}
+		Ok(())
+	}
 }
 
 /// Swap by Acala DEX which has specific joints.
diff --git a/modules/aggregated-dex/src/mock.rs b/modules/aggregated-dex/src/mock.rs
index aa1f824f1..b7f479d23 100644
--- a/modules/aggregated-dex/src/mock.rs
+++ b/modules/aggregated-dex/src/mock.rs
@@ -49,8 +49,15 @@ pub const BOB: AccountId = AccountId32::new([2u8; 32]);
 pub const AUSD: CurrencyId = CurrencyId::Token(TokenSymbol::AUSD);
 pub const DOT: CurrencyId = CurrencyId::Token(TokenSymbol::DOT);
 pub const LDOT: CurrencyId = CurrencyId::Token(TokenSymbol::LDOT);
+pub const BTC: CurrencyId = CurrencyId::Token(TokenSymbol::RENBTC);
 pub const STABLE_ASSET: CurrencyId = CurrencyId::StableAssetPoolToken(0);
 
+parameter_types! {
+	pub static AUSDBTCPair: TradingPair = TradingPair::from_currency_ids(AUSD, BTC).unwrap();
+	pub static AUSDDOTPair: TradingPair = TradingPair::from_currency_ids(AUSD, DOT).unwrap();
+	pub static DOTBTCPair: TradingPair = TradingPair::from_currency_ids(DOT, BTC).unwrap();
+}
+
 impl frame_system::Config for Runtime {
 	type BaseCallFilter = Everything;
 	type BlockWeights = ();
@@ -191,14 +198,18 @@ impl nutsfinance_stable_asset::Config for Runtime {
 parameter_types! {
 	pub static DexSwapJointList: Vec<Vec<CurrencyId>> = vec![];
 	pub const GetLiquidCurrencyId: CurrencyId = LDOT;
+	pub const TreasuryPalletId: PalletId = PalletId(*b"aca/trea");
 }
 
 impl Config for Runtime {
+	type Event = Event;
 	type DEX = Dex;
 	type StableAsset = StableAssetWrapper;
 	type GovernanceOrigin = EnsureSignedBy<Admin, AccountId>;
 	type DexSwapJointList = DexSwapJointList;
 	type SwapPathLimit = ConstU32<3>;
+	type TreasuryPallet = TreasuryPalletId;
+	type UnsignedPriority = ConstU64<1048576>; // 1 << 20
 	type WeightInfo = ();
 }
 
@@ -215,13 +226,23 @@ frame_support::construct_runtime!(
 		UncheckedExtrinsic = UncheckedExtrinsic
 	{
 		System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
-		AggregatedDex: aggregated_dex::{Pallet, Call, Storage},
+		AggregatedDex: aggregated_dex::{Pallet, Call, Storage, Event<T>},
 		Dex: module_dex::{Pallet, Call, Storage, Config<T>, Event<T>},
 		Tokens: orml_tokens::{Pallet, Storage, Event<T>, Config<T>},
 		StableAsset: nutsfinance_stable_asset::{Pallet, Call, Storage, Event<T>},
 	}
 );
 
+pub type Extrinsic = sp_runtime::testing::TestXt<Call, ()>;
+
+impl<LocalCall> frame_system::offchain::SendTransactionTypes<LocalCall> for Runtime
+where
+	Call: From<LocalCall>,
+{
+	type OverarchingCall = Call;
+	type Extrinsic = Extrinsic;
+}
+
 pub struct ExtBuilder {
 	balances: Vec<(AccountId, CurrencyId, Balance)>,
 }
diff --git a/modules/aggregated-dex/src/tests.rs b/modules/aggregated-dex/src/tests.rs
index 4f3379ca8..6f20f3dcb 100644
--- a/modules/aggregated-dex/src/tests.rs
+++ b/modules/aggregated-dex/src/tests.rs
@@ -22,9 +22,24 @@
 
 use super::*;
 use frame_support::{assert_noop, assert_ok};
-use mock::*;
+use mock::{Call as MockCall, Event, Origin, System, *};
 use nutsfinance_stable_asset::traits::StableAsset as StableAssetT;
+use parking_lot::RwLock;
+use sp_core::offchain::{
+	testing, testing::PoolState, DbExternalities, OffchainDbExt, OffchainWorkerExt, StorageKind, TransactionPoolExt,
+};
+use sp_io::offchain;
 use sp_runtime::traits::BadOrigin;
+use std::sync::Arc;
+
+fn run_to_block_offchain(n: u64) {
+	while System::block_number() < n {
+		System::set_block_number(System::block_number() + 1);
+		AggregatedDex::offchain_worker(System::block_number());
+		// this unlocks the concurrency storage lock so offchain_worker will fire next block
+		offchain::sleep_until(offchain::timestamp().add(Duration::from_millis(LOCK_DURATION + 200)));
+	}
+}
 
 fn set_dex_swap_joint_list(joints: Vec<Vec<CurrencyId>>) {
 	DexSwapJointList::set(joints);
@@ -68,13 +83,15 @@ fn initial_taiga_dot_ldot_pool() -> DispatchResult {
 		10_000_000_000u128,
 	)?;
 
-	Tokens::deposit(DOT, &BOB, 100_000_000_000u128)?;
-	Tokens::deposit(LDOT, &BOB, 1_000_000_000_000u128)?;
+	let amount = 100_000_000_000u128;
+	Tokens::deposit(DOT, &BOB, amount)?;
+	Tokens::deposit(LDOT, &BOB, amount * 10)?;
 
-	StableAssetWrapper::mint(&BOB, 0, vec![100_000_000_000u128, 1_000_000_000_000u128], 0)?;
+	// The DOT and LDOT convert rate in `mock::ConvertBalanceHoma` is 1/10.
+	StableAssetWrapper::mint(&BOB, 0, vec![amount, amount * 10], 0)?;
 	assert_eq!(
 		StableAssetWrapper::pool(0).map(|p| p.balances).unwrap(),
-		vec![100_000_000_000u128, 100_000_000_000u128]
+		vec![amount, amount]
 	);
 
 	Ok(())
@@ -682,25 +699,43 @@ fn check_swap_paths_work() {
 		);
 
 		assert_ok!(initial_taiga_dot_ldot_pool());
-		assert_ok!(AggregatedDex::check_swap_paths(&vec![SwapPath::Taiga(0, 0, 1)]));
+
 		assert_noop!(
 			AggregatedDex::check_swap_paths(&vec![SwapPath::Taiga(0, 2, 0)]),
 			Error::<Runtime>::InvalidTokenIndex
 		);
-
-		assert_ok!(AggregatedDex::check_swap_paths(&vec![
-			SwapPath::Taiga(0, 0, 1),
-			SwapPath::Dex(vec![LDOT, AUSD])
-		]),);
 		assert_noop!(
 			AggregatedDex::check_swap_paths(&vec![SwapPath::Taiga(0, 0, 1), SwapPath::Dex(vec![AUSD, LDOT])]),
 			Error::<Runtime>::InvalidSwapPath
 		);
-
-		assert_ok!(AggregatedDex::check_swap_paths(&vec![
-			SwapPath::Dex(vec![AUSD, LDOT]),
-			SwapPath::Taiga(0, 1, 0)
-		]),);
+		assert_eq!(
+			AggregatedDex::check_swap_paths(&vec![SwapPath::Taiga(0, 0, 1)]),
+			Ok((DOT, LDOT))
+		);
+		assert_eq!(
+			AggregatedDex::check_swap_paths(&vec![SwapPath::Taiga(0, 0, 1), SwapPath::Dex(vec![LDOT, AUSD])]),
+			Ok((DOT, AUSD))
+		);
+		assert_eq!(
+			AggregatedDex::check_swap_paths(&vec![SwapPath::Dex(vec![AUSD, LDOT]), SwapPath::Taiga(0, 1, 0)]),
+			Ok((AUSD, DOT))
+		);
+		assert_eq!(
+			AggregatedDex::check_swap_paths(&vec![SwapPath::Taiga(0, 0, 1), SwapPath::Dex(vec![LDOT, DOT]),]),
+			Ok((DOT, DOT))
+		);
+		assert_eq!(
+			AggregatedDex::check_swap_paths(&vec![SwapPath::Taiga(0, 1, 0), SwapPath::Dex(vec![DOT, LDOT]),]),
+			Ok((LDOT, LDOT))
+		);
+		assert_eq!(
+			AggregatedDex::check_swap_paths(&vec![SwapPath::Taiga(0, 1, 0), SwapPath::Taiga(0, 0, 1),]),
+			Ok((LDOT, LDOT))
+		);
+		assert_eq!(
+			AggregatedDex::check_swap_paths(&vec![SwapPath::Taiga(0, 0, 1), SwapPath::Taiga(0, 1, 0),]),
+			Ok((DOT, DOT))
+		);
 	});
 }
 
@@ -735,6 +770,8 @@ fn get_aggregated_swap_amount_work() {
 			100_000_000_000u128,
 			20_000_000_000_000u128
 		));
+
+		// dex
 		assert_eq!(
 			AggregatedDex::get_aggregated_swap_amount(
 				&vec![SwapPath::Dex(vec![AUSD, LDOT])],
@@ -771,6 +808,7 @@ fn get_aggregated_swap_amount_work() {
 			None
 		);
 
+		// taiga
 		assert_ok!(initial_taiga_dot_ldot_pool());
 		assert_eq!(
 			AggregatedDex::get_aggregated_swap_amount(
@@ -801,6 +839,7 @@ fn get_aggregated_swap_amount_work() {
 			None
 		);
 
+		// taiga + dex
 		assert_eq!(
 			AggregatedDex::get_aggregated_swap_amount(
 				&vec![SwapPath::Taiga(0, 0, 1), SwapPath::Dex(vec![LDOT, AUSD])],
@@ -830,6 +869,7 @@ fn get_aggregated_swap_amount_work() {
 			None
 		);
 
+		// dex + taiga
 		assert_eq!(
 			AggregatedDex::get_aggregated_swap_amount(
 				&vec![SwapPath::Dex(vec![AUSD, LDOT]), SwapPath::Taiga(0, 1, 0)],
@@ -851,6 +891,167 @@ fn get_aggregated_swap_amount_work() {
 			),
 			None
 		);
+
+		// more complicate aggregated dex test.
+		// We've already Taiga(DOT,LDOT), and Dex(LDOT, AUSD).
+		assert_ok!(inject_liquidity(DOT, AUSD, 100_000_000_000u128, 20_000_000_000_000u128));
+		assert_ok!(inject_liquidity(DOT, LDOT, 100_000_000_000u128, 100_000_000_000u128));
+
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![SwapPath::Taiga(0, 0, 1), SwapPath::Dex(vec![LDOT, DOT]),],
+				SwapLimit::ExactSupply(1_000_000_000u128, 0)
+			),
+			Some((1_000_000_000u128, 9_089_554_318u128))
+		);
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![SwapPath::Taiga(0, 0, 1), SwapPath::Dex(vec![LDOT, DOT]),],
+				SwapLimit::ExactTarget(1_000_000_000u128, 1_000_000_000u128)
+			),
+			Some((101_011_873u128, 1_000_000_960u128))
+		);
+
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![SwapPath::Taiga(0, 1, 0), SwapPath::Dex(vec![DOT, LDOT]),],
+				SwapLimit::ExactSupply(1_000_000_000u128, 0)
+			),
+			Some((1_000_000_000u128, 99_898_463u128))
+		);
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![SwapPath::Taiga(0, 1, 0), SwapPath::Dex(vec![DOT, LDOT]),],
+				SwapLimit::ExactTarget(2_000_000_000u128, 100_000_000u128)
+			),
+			Some((1_001_018_430u128, 100_000_098u128))
+		);
+
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![
+					SwapPath::Taiga(0, 0, 1),
+					SwapPath::Dex(vec![LDOT, AUSD]),
+					SwapPath::Dex(vec![AUSD, DOT]),
+				],
+				SwapLimit::ExactSupply(1_000_000_000u128, 0)
+			),
+			Some((1_000_000_000u128, 8_332_194_934u128))
+		);
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![
+					SwapPath::Taiga(0, 0, 1),
+					SwapPath::Dex(vec![LDOT, AUSD]),
+					SwapPath::Dex(vec![AUSD, DOT]),
+				],
+				SwapLimit::ExactTarget(1_000_000_000u128, 1_000_000_000u128)
+			),
+			Some((102_042_622u128, 1_000_000_938u128))
+		);
+
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![
+					SwapPath::Dex(vec![LDOT, AUSD]),
+					SwapPath::Dex(vec![AUSD, DOT]),
+					SwapPath::Dex(vec![DOT, LDOT]),
+				],
+				SwapLimit::ExactSupply(1_000_000_000u128, 0)
+			),
+			Some((1_000_000_000u128, 970_873_785u128))
+		);
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![
+					SwapPath::Dex(vec![LDOT, AUSD]),
+					SwapPath::Dex(vec![AUSD, DOT]),
+					SwapPath::Dex(vec![DOT, LDOT]),
+				],
+				SwapLimit::ExactTarget(1_000_000_000u128, 100_000_000u128)
+			),
+			Some((100_300_904u128, 100_000_000u128))
+		);
+
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![
+					SwapPath::Dex(vec![AUSD, DOT]),
+					SwapPath::Taiga(0, 0, 1),
+					SwapPath::Dex(vec![LDOT, AUSD]),
+				],
+				SwapLimit::ExactSupply(1_000_000_000u128, 0)
+			),
+			Some((1_000_000_000u128, 9_994_493_008u128))
+		);
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![
+					SwapPath::Dex(vec![AUSD, DOT]),
+					SwapPath::Taiga(0, 0, 1),
+					SwapPath::Dex(vec![LDOT, AUSD]),
+				],
+				SwapLimit::ExactTarget(1_000_000_000u128, 100_000_000u128)
+			),
+			Some((10_019_806u128, 100_195_498u128))
+		);
+
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![
+					SwapPath::Dex(vec![LDOT, AUSD]),
+					SwapPath::Dex(vec![AUSD, DOT]),
+					SwapPath::Dex(vec![DOT, LDOT]),
+					SwapPath::Dex(vec![LDOT, AUSD]),
+					SwapPath::Dex(vec![AUSD, DOT]),
+					SwapPath::Dex(vec![DOT, LDOT]),
+				],
+				SwapLimit::ExactSupply(1_000_000_000u128, 0)
+			),
+			Some((1_000_000_000u128, 943_396_225u128))
+		);
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![
+					SwapPath::Dex(vec![LDOT, AUSD]),
+					SwapPath::Dex(vec![AUSD, DOT]),
+					SwapPath::Dex(vec![DOT, LDOT]),
+					SwapPath::Dex(vec![LDOT, AUSD]),
+					SwapPath::Dex(vec![AUSD, DOT]),
+					SwapPath::Dex(vec![DOT, LDOT]),
+				],
+				SwapLimit::ExactTarget(2_000_000_000u128, 1_000_000_000u128)
+			),
+			Some((1_063_829_789u128, 1_000_000_000u128))
+		);
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![
+					SwapPath::Dex(vec![AUSD, DOT]),
+					SwapPath::Taiga(0, 0, 1),
+					SwapPath::Dex(vec![LDOT, AUSD]),
+					SwapPath::Dex(vec![AUSD, DOT]),
+					SwapPath::Taiga(0, 0, 1),
+					SwapPath::Dex(vec![LDOT, AUSD]),
+				],
+				SwapLimit::ExactSupply(1_000_000_000u128, 0)
+			),
+			Some((1_000_000_000u128, 99_397_727_227u128))
+		);
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![
+					SwapPath::Dex(vec![AUSD, DOT]),
+					SwapPath::Taiga(0, 0, 1),
+					SwapPath::Dex(vec![LDOT, AUSD]),
+					SwapPath::Dex(vec![AUSD, DOT]),
+					SwapPath::Taiga(0, 0, 1),
+					SwapPath::Dex(vec![LDOT, AUSD]),
+				],
+				SwapLimit::ExactTarget(2_000_000_000u128, 1_000_000_000u128)
+			),
+			Some((10_022_406u128, 1_002_155_781u128))
+		);
 	});
 }
 
@@ -1301,3 +1502,234 @@ fn aggregated_swap_swap_work() {
 		);
 	});
 }
+
+fn set_rebalance_info_works(token: CurrencyId, supply_amount: Balance, minimum_amount: Balance) {
+	// set swap supply and threshold
+	assert_ok!(AggregatedDex::set_rebalance_swap_info(
+		Origin::signed(BOB),
+		token,
+		supply_amount,
+		minimum_amount,
+	));
+	System::assert_last_event(Event::AggregatedDex(crate::Event::SetupRebalanceSwapInfo {
+		currency_id: token,
+		supply_amount: supply_amount,
+		threshold: minimum_amount,
+	}));
+	let supply_threshold = RebalanceSupplyThreshold::<Runtime>::get(token).unwrap();
+	assert_eq!(supply_threshold, (supply_amount, minimum_amount));
+}
+
+fn inject_liquidity_default_pairs() {
+	assert_ok!(inject_liquidity(AUSD, DOT, 1_000_000u128, 2_000_000u128));
+	assert_ok!(inject_liquidity(DOT, BTC, 1_000_000u128, 2_000_000u128));
+	assert_ok!(inject_liquidity(AUSD, BTC, 1_000_000u128, 2_000_000u128));
+}
+
+#[test]
+fn offchain_worker_max_iteration_works() {
+	let (mut offchain, _offchain_state) = testing::TestOffchainExt::new();
+	let (pool, pool_state) = testing::TestTransactionPoolExt::new();
+	let mut ext = ExtBuilder::default().build();
+	ext.register_extension(OffchainWorkerExt::new(offchain.clone()));
+	ext.register_extension(TransactionPoolExt::new(pool));
+	ext.register_extension(OffchainDbExt::new(offchain.clone()));
+
+	ext.execute_with(|| {
+		System::set_block_number(1);
+		inject_liquidity_default_pairs();
+
+		trigger_unsigned_rebalance_dex_swap(2, pool_state.clone(), vec![], vec![], None);
+
+		let to_be_continue = StorageValueRef::persistent(OFFCHAIN_WORKER_DATA);
+		let start_key = to_be_continue.get::<Vec<u8>>().unwrap_or_default();
+		assert_eq!(start_key, None);
+
+		// sets max iterations value to 1
+		offchain.local_storage_set(StorageKind::PERSISTENT, OFFCHAIN_WORKER_MAX_ITERATIONS, &1u32.encode());
+		trigger_unsigned_rebalance_dex_swap(3, pool_state.clone(), vec![], vec![], None);
+
+		let to_be_continue = StorageValueRef::persistent(OFFCHAIN_WORKER_DATA);
+		let start_key = to_be_continue.get::<Vec<u8>>().unwrap_or_default().unwrap();
+		let to_be_continue_currency = CurrencyId::decode(&mut &*start_key).unwrap();
+		assert_eq!(to_be_continue_currency, AUSD);
+	});
+}
+
+#[test]
+fn offchain_worker_unsigned_rebalance_dex_swap() {
+	let (offchain, _offchain_state) = testing::TestOffchainExt::new();
+	let (pool, pool_state) = testing::TestTransactionPoolExt::new();
+	let mut ext = ExtBuilder::default().build();
+	ext.register_extension(OffchainWorkerExt::new(offchain.clone()));
+	ext.register_extension(TransactionPoolExt::new(pool));
+	ext.register_extension(OffchainDbExt::new(offchain.clone()));
+
+	ext.execute_with(|| {
+		System::set_block_number(1);
+		inject_liquidity_default_pairs();
+
+		set_rebalance_info_works(AUSD, 1000, 1960);
+
+		assert_ok!(Tokens::deposit(
+			AUSD,
+			&Pallet::<Runtime>::treasury_account(),
+			1_000_000u128
+		));
+
+		// offchain worker execution trigger dex swap: AUSD->DOT-BTC->AUSD
+		trigger_unsigned_rebalance_dex_swap(
+			2,
+			pool_state.clone(),
+			vec![1000, 1998, 3988],
+			vec![3988, 1990],
+			Some(1990),
+		);
+		// treasury account use 1000 to swap 1990, that's gain 990.
+		assert_eq!(
+			Tokens::free_balance(AUSD, &Pallet::<Runtime>::treasury_account()),
+			1000990
+		);
+
+		// treasury account use 1000 to swap 1970, that's gain 970.
+		trigger_unsigned_rebalance_dex_swap(
+			3,
+			pool_state.clone(),
+			vec![1000, 1994, 3964],
+			vec![3964, 1970],
+			Some(1970),
+		);
+		assert_eq!(
+			Tokens::free_balance(AUSD, &Pallet::<Runtime>::treasury_account()),
+			1001960
+		);
+
+		trigger_unsigned_rebalance_dex_swap(4, pool_state.clone(), vec![], vec![], None);
+		assert_eq!(
+			Tokens::free_balance(AUSD, &Pallet::<Runtime>::treasury_account()),
+			1001960
+		);
+
+		// AUSD-DOT: AUSD+(1000+1000), DOT-(1998+1994)
+		assert_eq!(Dex::get_liquidity_pool(AUSD, DOT), (1002000, 1996008));
+		// DOT-BTC: DOT+(1998+1994), BTC-(3988+3964)
+		assert_eq!(Dex::get_liquidity_pool(DOT, BTC), (1003992, 1992048));
+		// BTC-AUSD: BTC+(3988+3964), AUSD-(1990+1970)
+		assert_eq!(Dex::get_liquidity_pool(AUSD, BTC), (996040, 2007952));
+	});
+}
+
+#[test]
+fn offchain_worker_unsigned_rebalance_aggregated_dex_swap() {
+	let (offchain, _offchain_state) = testing::TestOffchainExt::new();
+	let (pool, pool_state) = testing::TestTransactionPoolExt::new();
+	let mut ext = ExtBuilder::default().build();
+	ext.register_extension(OffchainWorkerExt::new(offchain.clone()));
+	ext.register_extension(TransactionPoolExt::new(pool));
+	ext.register_extension(OffchainDbExt::new(offchain.clone()));
+
+	ext.execute_with(|| {
+		System::set_block_number(1);
+
+		// Taiga(DOT, LDOT) + Dex(LDOT, DOT)
+		assert_ok!(initial_taiga_dot_ldot_pool());
+		assert_ok!(inject_liquidity(DOT, LDOT, 11_000_000_000u128, 100_000_000_000u128));
+
+		assert_eq!(
+			AggregatedDex::get_aggregated_swap_amount(
+				&vec![SwapPath::Taiga(0, 0, 1), SwapPath::Dex(vec![LDOT, DOT])],
+				SwapLimit::ExactSupply(1_000_000u128, 0)
+			),
+			Some((1_000_000u128, 1_099_888u128))
+		);
+
+		set_rebalance_info_works(DOT, 1_000_000, 1_050_000);
+
+		let swap_path = vec![SwapPath::Taiga(0, 0, 1), SwapPath::Dex(vec![LDOT, DOT])];
+		assert_ok!(AggregatedDex::update_rebalance_swap_paths(
+			Origin::signed(BOB),
+			vec![(DOT, Some(swap_path.clone()))]
+		));
+		let swap_paths = RebalanceSwapPaths::<Runtime>::get(DOT).unwrap();
+		assert_eq!(swap_paths.into_inner(), swap_path);
+
+		assert_ok!(Tokens::deposit(
+			DOT,
+			&Pallet::<Runtime>::treasury_account(),
+			10_000_000_000u128
+		));
+
+		System::reset_events();
+		run_to_block_offchain(2);
+		assert_unsigned_call_executed(pool_state);
+
+		System::assert_last_event(Event::AggregatedDex(crate::Event::RebalanceTrading {
+			currency_id: DOT,
+			supply_amount: 1000000,
+			target_amount: 1099888,
+			swap_path,
+		}));
+		assert!(System::events().iter().any(|r| {
+			matches!(
+				r.event,
+				crate::mock::Event::Dex(module_dex::Event::Swap { .. })
+					| crate::mock::Event::StableAsset(nutsfinance_stable_asset::Event::TokenSwapped { .. })
+			)
+		}));
+	});
+}
+
+fn assert_unsigned_call_executed(pool_state: Arc<RwLock<PoolState>>) {
+	let tx = pool_state.write().transactions.pop().unwrap();
+	let tx = Extrinsic::decode(&mut &*tx).unwrap();
+
+	if let MockCall::AggregatedDex(crate::Call::force_rebalance_swap { currency_id, swap_path }) = tx.call {
+		assert_ok!(AggregatedDex::force_rebalance_swap(
+			Origin::none(),
+			currency_id,
+			swap_path
+		));
+	}
+	assert!(pool_state.write().transactions.pop().is_none());
+}
+
+fn trigger_unsigned_rebalance_dex_swap(
+	n: u64,
+	pool_state: Arc<RwLock<PoolState>>,
+	dex_lp1: Vec<Balance>,
+	dex_lp2: Vec<Balance>,
+	actual_target_amount: Option<u128>,
+) {
+	System::reset_events();
+	run_to_block_offchain(n);
+	assert_unsigned_call_executed(pool_state);
+
+	let swap_path = vec![
+		AggregatedSwapPath::Dex(vec![AUSD, DOT, BTC]),
+		AggregatedSwapPath::Dex(vec![BTC, AUSD]),
+	];
+
+	// if target amount is less than threshold, then rebalance swap not triggered.
+	if let Some(target_amount) = actual_target_amount {
+		System::assert_has_event(crate::mock::Event::Dex(module_dex::Event::Swap {
+			trader: Pallet::<Runtime>::treasury_account(),
+			path: vec![AUSD, DOT, BTC],
+			liquidity_changes: dex_lp1,
+		}));
+		System::assert_has_event(crate::mock::Event::Dex(module_dex::Event::Swap {
+			trader: Pallet::<Runtime>::treasury_account(),
+			path: vec![BTC, AUSD],
+			liquidity_changes: dex_lp2,
+		}));
+		System::assert_last_event(Event::AggregatedDex(crate::Event::RebalanceTrading {
+			currency_id: AUSD,
+			supply_amount: 1000,
+			target_amount,
+			swap_path,
+		}));
+	} else {
+		assert!(System::events()
+			.iter()
+			.all(|r| { !matches!(r.event, Event::AggregatedDex(crate::Event::RebalanceTrading { .. })) }));
+	}
+}
diff --git a/modules/aggregated-dex/src/weights.rs b/modules/aggregated-dex/src/weights.rs
index 500b09be5..7a28b6ff0 100644
--- a/modules/aggregated-dex/src/weights.rs
+++ b/modules/aggregated-dex/src/weights.rs
@@ -48,6 +48,8 @@ use sp_std::marker::PhantomData;
 pub trait WeightInfo {
 	fn swap_with_exact_supply(u: u32, ) -> Weight;
 	fn update_aggregated_swap_paths(u: u32, ) -> Weight;
+	fn force_rebalance_swap() -> Weight;
+	fn set_rebalance_swap_info() -> Weight;
 }
 
 /// Weights for module_aggregated_dex using the Acala node and recommended hardware.
@@ -69,6 +71,14 @@ impl<T: frame_system::Config> WeightInfo for AcalaWeight<T> {
 			.saturating_add(T::DbWeight::get().reads((1 as Weight).saturating_mul(u as Weight)))
 			.saturating_add(T::DbWeight::get().writes((1 as Weight).saturating_mul(u as Weight)))
 	}
+
+	fn force_rebalance_swap() -> Weight {
+		2_268_000
+	}
+
+	fn set_rebalance_swap_info() -> Weight {
+		2_268_000
+	}
 }
 
 // For backwards compatibility and tests
@@ -89,4 +99,12 @@ impl WeightInfo for () {
 			.saturating_add(RocksDbWeight::get().reads((1 as Weight).saturating_mul(u as Weight)))
 			.saturating_add(RocksDbWeight::get().writes((1 as Weight).saturating_mul(u as Weight)))
 	}
+
+	fn force_rebalance_swap() -> Weight {
+		2_268_000
+	}
+
+	fn set_rebalance_swap_info() -> Weight {
+		2_268_000
+	}
 }
diff --git a/modules/auction-manager/src/lib.rs b/modules/auction-manager/src/lib.rs
index a5f491413..5c8d4e452 100644
--- a/modules/auction-manager/src/lib.rs
+++ b/modules/auction-manager/src/lib.rs
@@ -350,7 +350,6 @@ impl<T: Config> Pallet<T> {
 		let lock_expiration = Duration::from_millis(LOCK_DURATION);
 		let mut lock = StorageLock::<'_, Time>::with_deadline(OFFCHAIN_WORKER_LOCK, lock_expiration);
 		let mut guard = lock.try_lock().map_err(|_| OffchainErr::OffchainLock)?;
-
 		let mut to_be_continue = StorageValueRef::persistent(OFFCHAIN_WORKER_DATA);
 
 		// get to_be_continue record,
diff --git a/modules/dex/Cargo.toml b/modules/dex/Cargo.toml
index 1e0d9080f..936afbd8b 100644
--- a/modules/dex/Cargo.toml
+++ b/modules/dex/Cargo.toml
@@ -8,19 +8,21 @@ edition = "2021"
 serde = { version = "1.0.136", optional = true }
 codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["max-encoded-len"] }
 scale-info = { version = "2.1", default-features = false, features = ["derive"] }
-sp-core = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26", default-features = false }
-sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26", default-features = false }
+
 frame-support = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26", default-features = false }
 frame-system = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26", default-features = false }
+sp-core = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26", default-features = false }
+sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26", default-features = false }
 sp-std = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26", default-features = false }
+
 orml-traits = { path = "../../orml/traits", default-features = false }
 support = { package = "module-support", path = "../support", default-features = false }
 primitives = { package = "acala-primitives", path = "../../primitives", default-features = false }
 
 [dev-dependencies]
-orml-tokens = { path = "../../orml/tokens" }
-sp-core = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26" }
 sp-io = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26" }
+
+orml-tokens = { path = "../../orml/tokens" }
 pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.26" }
 
 [features]
@@ -29,9 +31,10 @@ std = [
 	"serde",
 	"codec/std",
 	"scale-info/std",
-	"sp-runtime/std",
 	"frame-support/std",
 	"frame-system/std",
+	"sp-core/std",
+	"sp-runtime/std",
 	"sp-std/std",
 	"orml-traits/std",
 	"support/std",
diff --git a/modules/dex/src/lib.rs b/modules/dex/src/lib.rs
index cc3732e2e..11384588d 100644
--- a/modules/dex/src/lib.rs
+++ b/modules/dex/src/lib.rs
@@ -87,6 +87,12 @@ impl<Balance, BlockNumber> Default for TradingPairStatus<Balance, BlockNumber> {
 	}
 }
 
+impl<Balance, BlockNumber> TradingPairStatus<Balance, BlockNumber> {
+	pub fn enabled(&self) -> bool {
+		matches!(self, TradingPairStatus::<_, _>::Enabled)
+	}
+}
+
 #[frame_support::pallet]
 pub mod module {
 	use super::*;
@@ -740,10 +746,7 @@ pub mod module {
 			let trading_pair =
 				TradingPair::from_currency_ids(currency_id_a, currency_id_b).ok_or(Error::<T>::InvalidCurrencyId)?;
 			ensure!(
-				matches!(
-					Self::trading_pair_statuses(trading_pair),
-					TradingPairStatus::<_, _>::Enabled
-				),
+				Self::trading_pair_statuses(trading_pair).enabled(),
 				Error::<T>::MustBeEnabled
 			);
 
@@ -1001,10 +1004,7 @@ impl<T: Config> Pallet<T> {
 		let trading_pair =
 			TradingPair::from_currency_ids(currency_id_a, currency_id_b).ok_or(Error::<T>::InvalidCurrencyId)?;
 		ensure!(
-			matches!(
-				Self::trading_pair_statuses(trading_pair),
-				TradingPairStatus::<_, _>::Enabled
-			),
+			Self::trading_pair_statuses(trading_pair).enabled(),
 			Error::<T>::MustBeEnabled,
 		);
 
@@ -1245,10 +1245,7 @@ impl<T: Config> Pallet<T> {
 			let trading_pair =
 				TradingPair::from_currency_ids(path[i], path[i + 1]).ok_or(Error::<T>::InvalidCurrencyId)?;
 			ensure!(
-				matches!(
-					Self::trading_pair_statuses(trading_pair),
-					TradingPairStatus::<_, _>::Enabled
-				),
+				Self::trading_pair_statuses(trading_pair).enabled(),
 				Error::<T>::MustBeEnabled
 			);
 			let (supply_pool, target_pool) = Self::get_liquidity(path[i], path[i + 1]);
@@ -1281,10 +1278,7 @@ impl<T: Config> Pallet<T> {
 			let trading_pair =
 				TradingPair::from_currency_ids(path[i - 1], path[i]).ok_or(Error::<T>::InvalidCurrencyId)?;
 			ensure!(
-				matches!(
-					Self::trading_pair_statuses(trading_pair),
-					TradingPairStatus::<_, _>::Enabled
-				),
+				Self::trading_pair_statuses(trading_pair).enabled(),
 				Error::<T>::MustBeEnabled
 			);
 			let (supply_pool, target_pool) = Self::get_liquidity(path[i - 1], path[i]);
diff --git a/modules/transaction-payment/src/mock.rs b/modules/transaction-payment/src/mock.rs
index 959e39031..d97b489d4 100644
--- a/modules/transaction-payment/src/mock.rs
+++ b/modules/transaction-payment/src/mock.rs
@@ -39,10 +39,7 @@ use sp_runtime::{
 	Perbill,
 };
 use sp_std::cell::RefCell;
-use support::{
-	mocks::{MockAddressMapping, MockStableAsset},
-	Price, SpecificJointsSwap,
-};
+use support::{mocks::MockAddressMapping, Price, SpecificJointsSwap};
 
 pub type AccountId = AccountId32;
 pub type BlockNumber = u64;
@@ -194,15 +191,6 @@ impl module_dex::Config for Runtime {
 	type OnLiquidityPoolUpdated = ();
 }
 
-impl module_aggregated_dex::Config for Runtime {
-	type DEX = DEXModule;
-	type StableAsset = MockStableAsset<CurrencyId, Balance, AccountId, BlockNumber>;
-	type GovernanceOrigin = EnsureSignedBy<Zero, AccountId>;
-	type DexSwapJointList = AlternativeSwapPathJointList;
-	type SwapPathLimit = ConstU32<3>;
-	type WeightInfo = ();
-}
-
 parameter_types! {
 	pub MaxSwapSlippageCompareToOracle: Ratio = Ratio::saturating_from_rational(1, 2);
 	pub static TransactionByteFee: u128 = 1;
diff --git a/runtime/acala/src/benchmarking/mod.rs b/runtime/acala/src/benchmarking/mod.rs
index ec81dd2ba..876523b21 100644
--- a/runtime/acala/src/benchmarking/mod.rs
+++ b/runtime/acala/src/benchmarking/mod.rs
@@ -26,6 +26,9 @@ pub mod utils {
 }
 
 // module benchmarking
+pub mod aggregated_dex {
+	include!("../../../mandala/src/benchmarking/aggregated_dex.rs");
+}
 pub mod asset_registry {
 	include!("../../../mandala/src/benchmarking/asset_registry.rs");
 }
diff --git a/runtime/acala/src/lib.rs b/runtime/acala/src/lib.rs
index afe466d45..f5ce47f78 100644
--- a/runtime/acala/src/lib.rs
+++ b/runtime/acala/src/lib.rs
@@ -1114,11 +1114,14 @@ impl module_dex::Config for Runtime {
 }
 
 impl module_aggregated_dex::Config for Runtime {
+	type Event = Event;
 	type DEX = Dex;
 	type StableAsset = RebasedStableAsset;
 	type GovernanceOrigin = EnsureRootOrHalfGeneralCouncil;
 	type DexSwapJointList = AlternativeSwapPathJointList;
 	type SwapPathLimit = ConstU32<3>;
+	type TreasuryPallet = TreasuryPalletId;
+	type UnsignedPriority = runtime_common::DexRebalanceSwapUnsignedPriority;
 	type WeightInfo = ();
 }
 
@@ -1777,6 +1780,7 @@ mod benches {
 	define_benchmarks!(
 		[module_dex, benchmarking::dex]
 		[module_dex_oracle, benchmarking::dex_oracle]
+		[module_aggregated_dex, benchmarking::aggregated_dex]
 		[module_asset_registry, benchmarking::asset_registry]
 		[module_auction_manager, benchmarking::auction_manager]
 		[module_cdp_engine, benchmarking::cdp_engine]
diff --git a/runtime/common/src/lib.rs b/runtime/common/src/lib.rs
index bf8af3256..669f7dcbb 100644
--- a/runtime/common/src/lib.rs
+++ b/runtime/common/src/lib.rs
@@ -90,6 +90,7 @@ parameter_types! {
 	pub CdpEngineUnsignedPriority: TransactionPriority = MinOperationalPriority::get() - 1000;
 	pub AuctionManagerUnsignedPriority: TransactionPriority = MinOperationalPriority::get() - 2000;
 	pub RenvmBridgeUnsignedPriority: TransactionPriority = MinOperationalPriority::get() - 3000;
+	pub DexRebalanceSwapUnsignedPriority: TransactionPriority = MinOperationalPriority::get() - 4000;
 }
 
 /// The call is allowed only if caller is a system contract.
diff --git a/runtime/integration-tests/src/aggregated_dex.rs b/runtime/integration-tests/src/aggregated_dex.rs
new file mode 100644
index 000000000..e60d88aa1
--- /dev/null
+++ b/runtime/integration-tests/src/aggregated_dex.rs
@@ -0,0 +1,436 @@
+// This file is part of Acala.
+
+// Copyright (C) 2020-2022 Acala Foundation.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+use crate::setup::*;
+use module_aggregated_dex::{DexSwap, SwapPath};
+use module_support::{Swap, SwapLimit};
+use primitives::currency::AssetMetadata;
+use primitives::CurrencyId::LiquidCrowdloan;
+use sp_std::collections::btree_map::BTreeMap;
+use std::sync::{Arc, Mutex};
+
+pub fn enable_stable_asset(currencies: Vec<CurrencyId>, amounts: Vec<u128>, minter: Option<AccountId>) {
+	let pool_asset = CurrencyId::StableAssetPoolToken(0);
+	let precisions = currencies.iter().map(|_| 1u128).collect::<Vec<_>>();
+	assert_ok!(StableAsset::create_pool(
+		Origin::root(),
+		pool_asset,
+		currencies, // assets
+		precisions,
+		0,                        // mint fee
+		25_000_000u128,           // swap fee
+		30_000_000u128,           // redeem fee
+		3000,                     // initialA
+		AccountId::from(BOB),     // fee recipient
+		AccountId::from(CHARLIE), // yield recipient
+		1_000_000_000_000u128,    // precision
+	));
+
+	let asset_metadata = AssetMetadata {
+		name: b"Token Name".to_vec(),
+		symbol: b"TN".to_vec(),
+		decimals: 12,
+		minimal_balance: 1,
+	};
+	assert_ok!(AssetRegistry::register_stable_asset(
+		RawOrigin::Root.into(),
+		Box::new(asset_metadata.clone())
+	));
+
+	assert_ok!(StableAsset::mint(
+		Origin::signed(minter.unwrap_or(AccountId::from(ALICE))),
+		0,
+		amounts,
+		0u128
+	));
+}
+
+fn inject_liquidity(
+	account_id: AccountId,
+	currency_id_a: CurrencyId,
+	currency_id_b: CurrencyId,
+	max_amount_a: Balance,
+	max_amount_b: Balance,
+) -> Result<(), &'static str> {
+	let _ = Dex::enable_trading_pair(Origin::root(), currency_id_a, currency_id_b);
+	Dex::add_liquidity(
+		Origin::signed(account_id),
+		currency_id_a,
+		currency_id_b,
+		max_amount_a,
+		max_amount_b,
+		Default::default(),
+		false,
+	)?;
+	Ok(())
+}
+
+#[test]
+fn aggregated_dex_works() {
+	ExtBuilder::default()
+		.balances(vec![
+			(
+				AccountId::from(ALICE),
+				RELAY_CHAIN_CURRENCY,
+				1000_000_000 * dollar(RELAY_CHAIN_CURRENCY),
+			),
+			(
+				AccountId::from(ALICE),
+				LIQUID_CURRENCY,
+				1000_000_000 * dollar(LIQUID_CURRENCY),
+			),
+		])
+		.build()
+		.execute_with(|| {
+			let relay_amount = 7_810_966_981_981_661;
+			let liquid_amount = 12_529_784_940_482_519;
+			enable_stable_asset(
+				vec![RELAY_CHAIN_CURRENCY, LIQUID_CURRENCY],
+				vec![relay_amount, liquid_amount],
+				None,
+			);
+			assert_ok!(inject_liquidity(
+				AccountId::from(ALICE),
+				RELAY_CHAIN_CURRENCY,
+				LIQUID_CURRENCY,
+				865_557_657_840_895,
+				7_223_448_012_928_381
+			));
+
+			// get_swap_amount of AcalaSwap + DexSwap
+			let (_, output) = AcalaSwap::get_swap_amount(
+				RELAY_CHAIN_CURRENCY,
+				LIQUID_CURRENCY,
+				SwapLimit::ExactSupply(1_000_000_000_000, 0),
+			)
+			.unwrap();
+			let target = DexSwap::<Runtime>::get_swap_amount(
+				LIQUID_CURRENCY,
+				RELAY_CHAIN_CURRENCY,
+				SwapLimit::ExactSupply(output, 0),
+			)
+			.unwrap();
+
+			// get_swap_amount of aggregated swap with specified path.
+			let aggregated = vec![
+				SwapPath::Taiga(0, 0, 1),
+				SwapPath::Dex(vec![LIQUID_CURRENCY, RELAY_CHAIN_CURRENCY]),
+			];
+			assert_ok!(AggregatedDex::update_aggregated_swap_paths(
+				Origin::root(),
+				vec![((RELAY_CHAIN_CURRENCY, RELAY_CHAIN_CURRENCY), Some(aggregated))]
+			));
+			let target1 = AcalaSwap::get_swap_amount(
+				RELAY_CHAIN_CURRENCY,
+				RELAY_CHAIN_CURRENCY,
+				SwapLimit::ExactSupply(1_000_000_000_000, 0),
+			)
+			.unwrap();
+			assert_eq!(target.1, target1.1);
+
+			// swap of AcalaSwap + DexSwap
+			let (_, output1) = AcalaSwap::swap(
+				&AccountId::from(ALICE),
+				RELAY_CHAIN_CURRENCY,
+				LIQUID_CURRENCY,
+				SwapLimit::ExactSupply(1_000_000_000_000, 0),
+			)
+			.unwrap();
+			let target1 = DexSwap::<Runtime>::swap(
+				&AccountId::from(ALICE),
+				LIQUID_CURRENCY,
+				RELAY_CHAIN_CURRENCY,
+				SwapLimit::ExactSupply(output, 0),
+			)
+			.unwrap();
+			assert_eq!(output, output1);
+			assert_eq!(target, target1);
+			assert_eq!(output, 10_059_807_103_250);
+
+			#[cfg(any(feature = "with-karura-runtime", feature = "with-acala-runtime"))]
+			assert_eq!(target, (output, 1_200_144_864_851));
+			#[cfg(feature = "with-mandala-runtime")]
+			assert_eq!(target, (output, 1_202_549_032_278));
+
+			let output2 = AcalaSwap::swap(
+				&AccountId::from(ALICE),
+				RELAY_CHAIN_CURRENCY,
+				RELAY_CHAIN_CURRENCY,
+				SwapLimit::ExactSupply(1_000_000_000_000, 0),
+			)
+			.unwrap();
+			#[cfg(any(feature = "with-karura-runtime", feature = "with-acala-runtime"))]
+			assert_eq!(output2.1, 1196811102574);
+			#[cfg(feature = "with-mandala-runtime")]
+			assert_eq!(output2.1, 1199205260813);
+		});
+}
+
+#[test]
+fn rebalance_swap_works() {
+	ExtBuilder::default()
+		.balances(vec![
+			(
+				AccountId::from(ALICE),
+				RELAY_CHAIN_CURRENCY,
+				1000_000_000 * dollar(RELAY_CHAIN_CURRENCY),
+			),
+			(
+				TreasuryAccount::get(),
+				RELAY_CHAIN_CURRENCY,
+				1000_000_000 * dollar(RELAY_CHAIN_CURRENCY),
+			),
+			(
+				AccountId::from(ALICE),
+				LIQUID_CURRENCY,
+				1000_000_000 * dollar(LIQUID_CURRENCY),
+			),
+		])
+		.build()
+		.execute_with(|| {
+			let relay_amount = 7_810_966_981_981_661;
+			let liquid_amount = 12_529_784_940_482_519;
+			enable_stable_asset(
+				vec![RELAY_CHAIN_CURRENCY, LIQUID_CURRENCY],
+				vec![relay_amount, liquid_amount],
+				None,
+			);
+			assert_ok!(inject_liquidity(
+				AccountId::from(ALICE),
+				RELAY_CHAIN_CURRENCY,
+				LIQUID_CURRENCY,
+				865_557_657_840_895,
+				7_223_448_012_928_381
+			));
+
+			let force_path = vec![
+				SwapPath::Taiga(0, 0, 1),
+				SwapPath::Dex(vec![LIQUID_CURRENCY, RELAY_CHAIN_CURRENCY]),
+			];
+			assert_noop!(
+				AcalaSwap::swap(
+					&AccountId::from(ALICE),
+					RELAY_CHAIN_CURRENCY,
+					RELAY_CHAIN_CURRENCY,
+					SwapLimit::ExactSupply(1_000_000_000_000, 0)
+				),
+				module_aggregated_dex::Error::<Runtime>::CannotSwap
+			);
+
+			assert_noop!(
+				AggregatedDex::force_rebalance_swap(Origin::root(), RELAY_CHAIN_CURRENCY, force_path.clone()),
+				sp_runtime::traits::BadOrigin
+			);
+			assert_ok!(AggregatedDex::force_rebalance_swap(
+				RawOrigin::None.into(),
+				RELAY_CHAIN_CURRENCY,
+				force_path.clone()
+			));
+			assert!(System::events().iter().all(|r| {
+				!matches!(
+					r.event,
+					Event::Dex(module_dex::Event::Swap { .. })
+						| Event::StableAsset(nutsfinance_stable_asset::Event::TokenSwapped { .. })
+				)
+			}));
+
+			assert_ok!(AggregatedDex::set_rebalance_swap_info(
+				Origin::root(),
+				RELAY_CHAIN_CURRENCY,
+				1_000_000_000_000,
+				1_000_000_000_001,
+			));
+
+			// AggregatedDex swap not worked because we're not setting AggregatedDex swap path.
+			assert_noop!(
+				AcalaSwap::swap(
+					&AccountId::from(ALICE),
+					RELAY_CHAIN_CURRENCY,
+					RELAY_CHAIN_CURRENCY,
+					SwapLimit::ExactSupply(1_000_000_000_000, 0)
+				),
+				module_aggregated_dex::Error::<Runtime>::CannotSwap
+			);
+
+			// Rebalance swap path only go into effect for offchain worker.
+			assert_ok!(AggregatedDex::force_rebalance_swap(
+				RawOrigin::None.into(),
+				RELAY_CHAIN_CURRENCY,
+				force_path.clone()
+			));
+			assert!(System::events().iter().any(|r| {
+				matches!(
+					r.event,
+					Event::Dex(module_dex::Event::Swap { .. })
+						| Event::StableAsset(nutsfinance_stable_asset::Event::TokenSwapped { .. })
+				)
+			}));
+			#[cfg(any(feature = "with-acala-runtime", feature = "with-karura-runtime"))]
+			let target_amount = 1_200_144_864_851;
+			#[cfg(feature = "with-mandala-runtime")]
+			let target_amount = 1_202_549_032_278;
+			System::assert_last_event(Event::AggregatedDex(module_aggregated_dex::Event::RebalanceTrading {
+				currency_id: RELAY_CHAIN_CURRENCY,
+				supply_amount: 1_000_000_000_000,
+				target_amount,
+				swap_path: force_path,
+			}));
+		});
+}
+
+#[test]
+fn produciton_rebalance_swap_path() {
+	ExtBuilder::default()
+		.balances(vec![
+			(
+				AccountId::from(ALICE),
+				NATIVE_CURRENCY,
+				10_000_000_000 * dollar(NATIVE_CURRENCY),
+			),
+			(
+				AccountId::from(ALICE),
+				RELAY_CHAIN_CURRENCY,
+				1_000_000_000 * dollar(NATIVE_CURRENCY),
+			),
+			(
+				AccountId::from(ALICE),
+				USD_CURRENCY,
+				10_000_000_000 * dollar(NATIVE_CURRENCY),
+			),
+			(
+				AccountId::from(ALICE),
+				LIQUID_CURRENCY,
+				10_000_000_000 * dollar(NATIVE_CURRENCY),
+			),
+			(
+				AccountId::from(ALICE),
+				LiquidCrowdloan(13),
+				10_000_000_000 * dollar(NATIVE_CURRENCY),
+			),
+			(
+				TreasuryAccount::get(),
+				RELAY_CHAIN_CURRENCY,
+				1_000_000_000 * dollar(NATIVE_CURRENCY),
+			),
+		])
+		.build()
+		.execute_with(|| {
+			let relay_amount = 280_051_126_541_970;
+			let liquid_amount = 1_205_900_671_542_331;
+
+			enable_stable_asset(
+				vec![RELAY_CHAIN_CURRENCY, LIQUID_CURRENCY],
+				vec![relay_amount, liquid_amount],
+				None,
+			);
+
+			let minimal_balance = Balances::minimum_balance() / 10;
+			assert_ok!(AssetRegistry::register_foreign_asset(
+				Origin::root(),
+				Box::new(MultiLocation::new(1, X1(Parachain(2001))).into()),
+				Box::new(AssetMetadata {
+					name: b"interlay BTC".to_vec(),
+					symbol: b"iBTC".to_vec(),
+					decimals: 8,
+					minimal_balance
+				})
+			));
+			assert_ok!(Currencies::deposit(
+				CurrencyId::ForeignAsset(0),
+				&AccountId::from(ALICE),
+				1_000_000_000 * dollar(NATIVE_CURRENCY)
+			));
+
+			let trading_pair_values_map = dex_pools();
+
+			let rebalance_paths = Arc::new(Mutex::new(BTreeMap::new()));
+			#[cfg(any(feature = "with-acala-runtime", feature = "with-karura-runtime"))]
+			let last_currency_id = USD_CURRENCY;
+			#[cfg(feature = "with-mandala-runtime")]
+			let last_currency_id = RELAY_CHAIN_CURRENCY;
+			assert_eq!(
+				Ok((true, Some(last_currency_id))),
+				module_aggregated_dex::Pallet::<Runtime>::calculate_rebalance_paths(
+					10,
+					None,
+					None,
+					|currency_id, swap_path| {
+						rebalance_paths.lock().unwrap().insert(currency_id, swap_path);
+						()
+					}
+				)
+			);
+
+			let rebalance_paths = rebalance_paths.lock().unwrap();
+			for (currency_id, swap_path) in rebalance_paths.iter() {
+				let pairs = trading_pair_values_map.get(currency_id).unwrap();
+				assert_eq!(swap_path, pairs);
+			}
+		});
+}
+
+fn dex_pools() -> BTreeMap<CurrencyId, Vec<SwapPath>> {
+	assert_ok!(inject_liquidity(
+		AccountId::from(ALICE),
+		USD_CURRENCY,
+		LIQUID_CURRENCY,
+		3_760_432_120_659_928_418,
+		1_276_237_324_617_138
+	));
+	assert_ok!(inject_liquidity(
+		AccountId::from(ALICE),
+		USD_CURRENCY,
+		CurrencyId::ForeignAsset(0),
+		1_691_588_973_592_287_955_985,
+		274_627_356
+	));
+	assert_ok!(inject_liquidity(
+		AccountId::from(ALICE),
+		USD_CURRENCY,
+		LiquidCrowdloan(13),
+		8_849_894_746_344_149_013,
+		229_803_827_696_334
+	));
+	assert_ok!(inject_liquidity(
+		AccountId::from(ALICE),
+		NATIVE_CURRENCY,
+		USD_CURRENCY,
+		338_237_683_713_930_724,
+		9_083_201_752_524_763_780
+	));
+	assert_ok!(inject_liquidity(
+		AccountId::from(ALICE),
+		RELAY_CHAIN_CURRENCY,
+		LiquidCrowdloan(13),
+		1_727_685_431_872_727,
+		4_401_401_349_880_089
+	));
+
+	let mut trading_pair_values_map: BTreeMap<CurrencyId, Vec<SwapPath>> = BTreeMap::new();
+	let native_pairs = vec![
+		SwapPath::Dex(vec![NATIVE_CURRENCY, USD_CURRENCY, RELAY_CHAIN_CURRENCY]),
+		SwapPath::Dex(vec![RELAY_CHAIN_CURRENCY, NATIVE_CURRENCY]),
+	];
+	let usd_pairs = vec![
+		SwapPath::Dex(vec![USD_CURRENCY, RELAY_CHAIN_CURRENCY, LiquidCrowdloan(13)]),
+		SwapPath::Dex(vec![LiquidCrowdloan(13), USD_CURRENCY]),
+	];
+	trading_pair_values_map.insert(NATIVE_CURRENCY, native_pairs);
+	trading_pair_values_map.insert(USD_CURRENCY, usd_pairs);
+	trading_pair_values_map
+}
diff --git a/runtime/integration-tests/src/lib.rs b/runtime/integration-tests/src/lib.rs
index ef2eeb9ee..09accb595 100644
--- a/runtime/integration-tests/src/lib.rs
+++ b/runtime/integration-tests/src/lib.rs
@@ -39,6 +39,13 @@ mod authority;
 ))]
 mod dex;
 
+#[cfg(any(
+	feature = "with-mandala-runtime",
+	feature = "with-karura-runtime",
+	feature = "with-acala-runtime"
+))]
+mod aggregated_dex;
+
 #[cfg(any(
 	feature = "with-mandala-runtime",
 	feature = "with-karura-runtime",
diff --git a/runtime/integration-tests/src/stable_asset.rs b/runtime/integration-tests/src/stable_asset.rs
index 2d6c14a5c..fdfbbba78 100644
--- a/runtime/integration-tests/src/stable_asset.rs
+++ b/runtime/integration-tests/src/stable_asset.rs
@@ -88,6 +88,7 @@ fn stable_asset_mint_works() {
 		])
 		.build()
 		.execute_with(|| {
+			// Default exchange rate
 			let exchange_rate = Homa::current_exchange_rate();
 			assert_eq!(exchange_rate, ExchangeRate::saturating_from_rational(1, 10)); // 0.1
 
diff --git a/runtime/karura/src/benchmarking/mod.rs b/runtime/karura/src/benchmarking/mod.rs
index 1a3252be2..56f2af53b 100644
--- a/runtime/karura/src/benchmarking/mod.rs
+++ b/runtime/karura/src/benchmarking/mod.rs
@@ -26,6 +26,9 @@ pub mod utils {
 }
 
 // module benchmarking
+pub mod aggregated_dex {
+	include!("../../../mandala/src/benchmarking/aggregated_dex.rs");
+}
 pub mod asset_registry {
 	include!("../../../mandala/src/benchmarking/asset_registry.rs");
 }
diff --git a/runtime/karura/src/lib.rs b/runtime/karura/src/lib.rs
index 3fbfa9046..5716abbab 100644
--- a/runtime/karura/src/lib.rs
+++ b/runtime/karura/src/lib.rs
@@ -1120,11 +1120,14 @@ impl module_dex::Config for Runtime {
 }
 
 impl module_aggregated_dex::Config for Runtime {
+	type Event = Event;
 	type DEX = Dex;
 	type StableAsset = RebasedStableAsset;
 	type GovernanceOrigin = EnsureRootOrHalfGeneralCouncil;
 	type DexSwapJointList = AlternativeSwapPathJointList;
 	type SwapPathLimit = ConstU32<3>;
+	type TreasuryPallet = TreasuryPalletId;
+	type UnsignedPriority = runtime_common::DexRebalanceSwapUnsignedPriority;
 	type WeightInfo = ();
 }
 
@@ -1810,6 +1813,7 @@ mod benches {
 	define_benchmarks!(
 		[module_dex, benchmarking::dex]
 		[module_dex_oracle, benchmarking::dex_oracle]
+		[module_aggregated_dex, benchmarking::aggregated_dex]
 		[module_asset_registry, benchmarking::asset_registry]
 		[module_auction_manager, benchmarking::auction_manager]
 		[module_cdp_engine, benchmarking::cdp_engine]
diff --git a/runtime/mandala/src/benchmarking/aggregated_dex.rs b/runtime/mandala/src/benchmarking/aggregated_dex.rs
new file mode 100644
index 000000000..b40d249fb
--- /dev/null
+++ b/runtime/mandala/src/benchmarking/aggregated_dex.rs
@@ -0,0 +1,129 @@
+// This file is part of Acala.
+
+// Copyright (C) 2020-2022 Acala Foundation.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+use super::utils::{create_stable_pools, dollar, inject_liquidity, LIQUID, NATIVE, SEED, STABLECOIN, STAKING};
+use crate::{AccountId, AggregatedDex, Balance, Currencies, Dex, Runtime, System, TreasuryPalletId};
+use frame_benchmarking::account;
+use frame_support::assert_ok;
+use frame_system::RawOrigin;
+use module_aggregated_dex::SwapPath;
+use module_support::DEXManager;
+use orml_traits::MultiCurrency;
+use sp_runtime::traits::AccountIdConversion;
+
+runtime_benchmarks! {
+	{ Runtime, module_aggregated_dex }
+
+	update_aggregated_swap_paths {
+		let funder: AccountId = account("funder", 0, SEED);
+
+		create_stable_pools(vec![STAKING, LIQUID], vec![1, 1])?;
+		inject_liquidity(funder.clone(), LIQUID, NATIVE, 1000 * dollar(LIQUID), 1000 * dollar(NATIVE), false)?;
+
+		let swap_path = vec![
+			SwapPath::Taiga(0, 0, 1),
+			SwapPath::Dex(vec![LIQUID, NATIVE])
+		];
+
+		let updates = vec![((STAKING, NATIVE), Some(swap_path.clone()))];
+	}: _(RawOrigin::Root, updates)
+	verify {
+		assert_eq!(module_aggregated_dex::AggregatedSwapPaths::<Runtime>::get((STAKING, NATIVE)).unwrap().into_inner(), swap_path);
+	}
+
+	update_rebalance_swap_paths {
+		let funder: AccountId = account("funder", 0, SEED);
+
+		create_stable_pools(vec![STAKING, LIQUID], vec![1, 1])?;
+		inject_liquidity(funder.clone(), LIQUID, STAKING, 1000 * dollar(LIQUID), 1000 * dollar(STAKING), false)?;
+
+		let swap_path = vec![
+			SwapPath::Taiga(0, 0, 1),
+			SwapPath::Dex(vec![LIQUID, STAKING])
+		];
+
+		let updates = vec![(STAKING, Some(swap_path.clone()))];
+	}: _(RawOrigin::Root, updates)
+	verify {
+		assert_eq!(module_aggregated_dex::RebalanceSwapPaths::<Runtime>::get(STAKING).unwrap().into_inner(), swap_path);
+	}
+
+	set_rebalance_swap_info {
+		let supply_amount: Balance = 100_000_000_000_000;
+		let threshold: Balance = 110_000_000_000_000;
+	}: _(RawOrigin::Root, STABLECOIN, supply_amount, threshold)
+	verify {
+		System::assert_has_event(module_aggregated_dex::Event::SetupRebalanceSwapInfo {
+			currency_id: STABLECOIN,
+			supply_amount,
+			threshold,
+		}.into());
+	}
+
+	force_rebalance_swap {
+		let funder: AccountId = account("funder", 0, SEED);
+		let supply: Balance = 10 * dollar(STABLECOIN);
+		let threshold: Balance = 11 * dollar(STABLECOIN);
+
+		inject_liquidity(funder.clone(), STABLECOIN, STAKING, 1000 * dollar(STABLECOIN), 1200 * dollar(STAKING), false)?;
+		inject_liquidity(funder.clone(), STAKING, NATIVE, 1000 * dollar(STAKING), 1000 * dollar(NATIVE), false)?;
+		inject_liquidity(funder.clone(), NATIVE, STABLECOIN, 1000 * dollar(NATIVE), 1000 * dollar(STABLECOIN), false)?;
+
+		assert_ok!(AggregatedDex::set_rebalance_swap_info(RawOrigin::Root.into(), STABLECOIN, supply, threshold));
+
+		let treasury_account: AccountId = TreasuryPalletId::get().into_account_truncating();
+		Currencies::deposit(
+			STABLECOIN,
+			&treasury_account,
+			100 * dollar(STABLECOIN),
+		)?;
+
+		let swap_path = vec![
+			SwapPath::Dex(vec![STABLECOIN, STAKING]),
+			SwapPath::Dex(vec![STAKING, NATIVE]),
+			SwapPath::Dex(vec![NATIVE, STABLECOIN])
+		];
+	}: _(RawOrigin::None, STABLECOIN, swap_path)
+	verify {
+		assert_eq!(Dex::get_liquidity_pool(STABLECOIN, STAKING).0, 1000 * dollar(STABLECOIN) + supply);
+		#[cfg(any(feature = "with-karura-runtime"))]
+		assert_eq!(
+			1200 * dollar(STAKING) - Dex::get_liquidity_pool(STABLECOIN, STAKING).1,
+			Dex::get_liquidity_pool(STAKING, NATIVE).0 - 1000 * dollar(STAKING)
+		);
+		#[cfg(any(feature = "with-karura-runtime"))]
+		assert_eq!(
+			1000 * dollar(STAKING) - Dex::get_liquidity_pool(STAKING, NATIVE).1,
+			Dex::get_liquidity_pool(NATIVE, STABLECOIN).0 - 1000 * dollar(NATIVE)
+		);
+		#[cfg(any(feature = "with-karura-runtime"))]
+		assert_eq!(
+			1000 * dollar(STAKING) - Dex::get_liquidity_pool(NATIVE, STABLECOIN).1,
+			Currencies::free_balance(STABLECOIN, &treasury_account) - 90 * dollar(STABLECOIN)
+		);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::benchmarking::utils::tests::new_test_ext;
+	use orml_benchmarking::impl_benchmark_test_suite;
+
+	impl_benchmark_test_suite!(new_test_ext(),);
+}
diff --git a/runtime/mandala/src/benchmarking/mod.rs b/runtime/mandala/src/benchmarking/mod.rs
index f7ffc34e9..49c954741 100644
--- a/runtime/mandala/src/benchmarking/mod.rs
+++ b/runtime/mandala/src/benchmarking/mod.rs
@@ -26,6 +26,7 @@ use sp_std::prelude::*;
 pub mod utils;
 
 // module benchmarking
+pub mod aggregated_dex;
 pub mod asset_registry;
 pub mod auction_manager;
 pub mod cdp_engine;
diff --git a/runtime/mandala/src/benchmarking/utils.rs b/runtime/mandala/src/benchmarking/utils.rs
index 29c24addb..519fab6ea 100644
--- a/runtime/mandala/src/benchmarking/utils.rs
+++ b/runtime/mandala/src/benchmarking/utils.rs
@@ -42,7 +42,7 @@ pub const NATIVE: CurrencyId = GetNativeCurrencyId::get();
 pub const STABLECOIN: CurrencyId = GetStableCurrencyId::get();
 pub const LIQUID: CurrencyId = GetLiquidCurrencyId::get();
 pub const STAKING: CurrencyId = GetStakingCurrencyId::get();
-const SEED: u32 = 0;
+pub const SEED: u32 = 0;
 
 pub fn lookup_of_account(who: AccountId) -> <<Runtime as frame_system::Config>::Lookup as StaticLookup>::Source {
 	<Runtime as frame_system::Config>::Lookup::unlookup(who)
diff --git a/runtime/mandala/src/lib.rs b/runtime/mandala/src/lib.rs
index 35b3cc303..f47f064e8 100644
--- a/runtime/mandala/src/lib.rs
+++ b/runtime/mandala/src/lib.rs
@@ -1178,11 +1178,14 @@ impl module_dex::Config for Runtime {
 }
 
 impl module_aggregated_dex::Config for Runtime {
+	type Event = Event;
 	type DEX = Dex;
 	type StableAsset = RebasedStableAsset;
 	type GovernanceOrigin = EnsureRootOrHalfGeneralCouncil;
 	type DexSwapJointList = AlternativeSwapPathJointList;
 	type SwapPathLimit = ConstU32<3>;
+	type TreasuryPallet = TreasuryPalletId;
+	type UnsignedPriority = runtime_common::DexRebalanceSwapUnsignedPriority;
 	type WeightInfo = ();
 }
 
@@ -2057,10 +2060,11 @@ extern crate orml_benchmarking;
 #[cfg(feature = "runtime-benchmarks")]
 mod benches {
 	define_benchmarks!(
-		[module_dex, benchmarking::dex]
-		[module_dex_oracle, benchmarking::dex_oracle]
 		[module_asset_registry, benchmarking::asset_registry]
+		[module_aggregated_dex, benchmarking::aggregated_dex]
 		[module_auction_manager, benchmarking::auction_manager]
+		[module_dex, benchmarking::dex]
+		[module_dex_oracle, benchmarking::dex_oracle]
 		[module_cdp_engine, benchmarking::cdp_engine]
 		[module_earning, benchmarking::earning]
 		[module_emergency_shutdown, benchmarking::emergency_shutdown]