Merge branch 'main' into fix/partial-fulfillments

libs/mock-builder/src/lib.rs

@@ -122,8 +122,10 @@
 //! }
 //! ```
 //!
-//! Take a look to the [pallet tests](`tests/pallet.rs`) to have a user view of
-//! how to use a *mock pallet*. It supports any kind of trait, with reference
+//! Take a look to the [pallet
+//! tests](https://github.com/foss3/runtime-pallet-library/blob/main/mock-builder/tests/pallet.rs)
+//! to have a user view of how to use a *mock pallet*.
+//! It supports any kind of trait, with reference
 //! parameters and generics at trait level and method level.
 //!
 //! ## Mock pallet creation
@@ -345,9 +347,6 @@ macro_rules! execute_call {
 	($input:expr) => {{
 		$crate::execute::<CallIds<T>, _, _, _>(|| (), $input)
 	}};
-	($input:expr, $gen:expr) => {{
-		$crate::execute::<CallIds<$gen>, _, _, _>(|| (), $input)
-	}};
 }
 
 /// Execute a function from the function storage for a pallet with instances.

libs/mocks/src/currency_conversion.rs

@@ -0,0 +1,47 @@
+#[frame_support::pallet]
+pub mod pallet {
+	use cfg_traits::IdentityCurrencyConversion;
+	use frame_support::pallet_prelude::*;
+	use mock_builder::{execute_call, register_call};
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type Balance;
+		type CurrencyId;
+	}
+
+	#[pallet::pallet]
+	#[pallet::generate_store(pub(super) trait Store)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::storage]
+	pub(super) type CallIds<T: Config> = StorageMap<
+		_,
+		Blake2_128Concat,
+		<Blake2_128 as frame_support::StorageHasher>::Output,
+		mock_builder::CallId,
+	>;
+
+	impl<T: Config> Pallet<T> {
+		pub fn mock_stable_to_stable(
+			f: impl Fn(T::CurrencyId, T::CurrencyId, T::Balance) -> Result<T::Balance, DispatchError>
+				+ 'static,
+		) {
+			register_call!(move |(a, b, c)| f(a, b, c));
+		}
+	}
+
+	impl<T: Config> IdentityCurrencyConversion for Pallet<T> {
+		type Balance = T::Balance;
+		type Currency = T::CurrencyId;
+		type Error = DispatchError;
+
+		fn stable_to_stable(
+			a: Self::Currency,
+			b: Self::Currency,
+			c: Self::Balance,
+		) -> Result<Self::Balance, DispatchError> {
+			execute_call!((a, b, c))
+		}
+	}
+}

libs/mocks/src/investment.rs

@@ -0,0 +1,160 @@
+#[frame_support::pallet]
+pub mod pallet {
+	use cfg_traits::investments::{Investment, InvestmentCollector};
+	use frame_support::pallet_prelude::*;
+	use mock_builder::{execute_call, register_call};
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type Amount;
+		type CurrencyId;
+		type InvestmentId;
+	}
+
+	#[pallet::pallet]
+	#[pallet::generate_store(pub(super) trait Store)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::storage]
+	pub(super) type CallIds<T: Config> = StorageMap<
+		_,
+		Blake2_128Concat,
+		<Blake2_128 as frame_support::StorageHasher>::Output,
+		mock_builder::CallId,
+	>;
+
+	impl<T: Config> Pallet<T> {
+		pub fn mock_update_investment(
+			f: impl Fn(&T::AccountId, T::InvestmentId, T::Amount) -> DispatchResult + 'static,
+		) {
+			register_call!(move |(a, b, c)| f(a, b, c));
+		}
+
+		pub fn mock_accepted_payment_currency(
+			f: impl Fn(T::InvestmentId, T::CurrencyId) -> bool + 'static,
+		) {
+			register_call!(move |(a, b)| f(a, b));
+		}
+
+		pub fn mock_investment(
+			f: impl Fn(&T::AccountId, T::InvestmentId) -> Result<T::Amount, DispatchError> + 'static,
+		) {
+			register_call!(move |(a, b)| f(a, b));
+		}
+
+		pub fn mock_update_redemption(
+			f: impl Fn(&T::AccountId, T::InvestmentId, T::Amount) -> DispatchResult + 'static,
+		) {
+			register_call!(move |(a, b, c)| f(a, b, c));
+		}
+
+		pub fn mock_accepted_payout_currency(
+			f: impl Fn(T::InvestmentId, T::CurrencyId) -> bool + 'static,
+		) {
+			register_call!(move |(a, b)| f(a, b));
+		}
+
+		pub fn mock_redemption(
+			f: impl Fn(&T::AccountId, T::InvestmentId) -> Result<T::Amount, DispatchError> + 'static,
+		) {
+			register_call!(move |(a, b)| f(a, b));
+		}
+
+		pub fn mock_collect_investment(
+			f: impl Fn(T::AccountId, T::InvestmentId) -> Result<(), DispatchError> + 'static,
+		) {
+			register_call!(move |(a, b)| f(a, b));
+		}
+
+		pub fn mock_collect_redemption(
+			f: impl Fn(T::AccountId, T::InvestmentId) -> Result<(), DispatchError> + 'static,
+		) {
+			register_call!(move |(a, b)| f(a, b));
+		}
+
+		pub fn mock_investment_requires_collect(
+			f: impl Fn(&T::AccountId, T::InvestmentId) -> bool + 'static,
+		) {
+			register_call!(move |(a, b)| f(a, b));
+		}
+
+		pub fn mock_redemption_requires_collect(
+			f: impl Fn(&T::AccountId, T::InvestmentId) -> bool + 'static,
+		) {
+			register_call!(move |(a, b)| f(a, b));
+		}
+	}
+
+	impl<T: Config> Investment<T::AccountId> for Pallet<T> {
+		type Amount = T::Amount;
+		type CurrencyId = T::CurrencyId;
+		type Error = DispatchError;
+		type InvestmentId = T::InvestmentId;
+
+		fn update_investment(
+			a: &T::AccountId,
+			b: Self::InvestmentId,
+			c: Self::Amount,
+		) -> DispatchResult {
+			execute_call!((a, b, c))
+		}
+
+		fn accepted_payment_currency(a: Self::InvestmentId, b: Self::CurrencyId) -> bool {
+			execute_call!((a, b))
+		}
+
+		fn investment(
+			a: &T::AccountId,
+			b: Self::InvestmentId,
+		) -> Result<Self::Amount, Self::Error> {
+			execute_call!((a, b))
+		}
+
+		fn update_redemption(
+			a: &T::AccountId,
+			b: Self::InvestmentId,
+			c: Self::Amount,
+		) -> DispatchResult {
+			execute_call!((a, b, c))
+		}
+
+		fn accepted_payout_currency(a: Self::InvestmentId, b: Self::CurrencyId) -> bool {
+			execute_call!((a, b))
+		}
+
+		fn redemption(
+			a: &T::AccountId,
+			b: Self::InvestmentId,
+		) -> Result<Self::Amount, Self::Error> {
+			execute_call!((a, b))
+		}
+
+		fn investment_requires_collect(a: &T::AccountId, b: T::InvestmentId) -> bool {
+			execute_call!((a, b))
+		}
+
+		fn redemption_requires_collect(a: &T::AccountId, b: T::InvestmentId) -> bool {
+			execute_call!((a, b))
+		}
+	}
+
+	impl<T: Config> InvestmentCollector<T::AccountId> for Pallet<T> {
+		type Error = DispatchError;
+		type InvestmentId = T::InvestmentId;
+		type Result = ();
+
+		fn collect_investment(
+			a: T::AccountId,
+			b: Self::InvestmentId,
+		) -> Result<Self::Result, Self::Error> {
+			execute_call!((a, b))
+		}
+
+		fn collect_redemption(
+			a: T::AccountId,
+			b: Self::InvestmentId,
+		) -> Result<Self::Result, Self::Error> {
+			execute_call!((a, b))
+		}
+	}
+}

libs/mocks/src/lib.rs

@@ -1,24 +1,32 @@
 mod change_guard;
+mod currency_conversion;
 mod data;
 mod fees;
+mod investment;
 mod liquidity_pools;
 mod liquidity_pools_gateway_routers;
 mod permissions;
 mod pools;
 mod rewards;
+mod status_notification;
 mod time;
+mod token_swaps;
 mod try_convert;
 mod write_off_policy;
 
 pub use change_guard::pallet_mock_change_guard;
+pub use currency_conversion::pallet as pallet_mock_currency_conversion;
 pub use data::pallet as pallet_mock_data;
 pub use fees::pallet as pallet_mock_fees;
+pub use investment::pallet as pallet_mock_investment;
 pub use liquidity_pools::{pallet as pallet_mock_liquidity_pools, MessageMock};
 pub use liquidity_pools_gateway_routers::{pallet as pallet_mock_routers, RouterMock};
 pub use permissions::pallet as pallet_mock_permissions;
 pub use pools::pallet as pallet_mock_pools;
 pub use rewards::pallet as pallet_mock_rewards;
+pub use status_notification::pallet as pallet_mock_status_notification;
 pub use time::pallet as pallet_mock_time;
+pub use token_swaps::pallet as pallet_mock_token_swaps;
 pub use try_convert::pallet as pallet_mock_try_convert;
 pub use write_off_policy::pallet as pallet_mock_write_off_policy;
 

libs/mocks/src/status_notification.rs

@@ -0,0 +1,40 @@
+#[frame_support::pallet]
+pub mod pallet {
+	use cfg_traits::StatusNotificationHook;
+	use frame_support::pallet_prelude::*;
+	use mock_builder::{execute_call_instance, register_call_instance};
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		type Id;
+		type Status;
+	}
+
+	#[pallet::pallet]
+	#[pallet::generate_store(pub(super) trait Store)]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[pallet::storage]
+	pub(super) type CallIds<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Blake2_128Concat,
+		<Blake2_128 as frame_support::StorageHasher>::Output,
+		mock_builder::CallId,
+	>;
+
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		pub fn mock_notify_status_change(f: impl Fn(T::Id, T::Status) -> DispatchResult + 'static) {
+			register_call_instance!(move |(a, b)| f(a, b));
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> StatusNotificationHook for Pallet<T, I> {
+		type Error = DispatchError;
+		type Id = T::Id;
+		type Status = T::Status;
+
+		fn notify_status_change(a: Self::Id, b: Self::Status) -> DispatchResult {
+			execute_call_instance!((a, b))
+		}
+	}
+}