OrderBook: Add market prices using Oracles

libs/mocks/src/token_swaps.rs

@@ -1,14 +1,14 @@
 #[frame_support::pallet]
 pub mod pallet {
-	use cfg_traits::TokenSwaps;
+	use cfg_traits::{OrderRatio, TokenSwaps};
 	use frame_support::pallet_prelude::*;
 	use mock_builder::{execute_call, register_call};
 
 	#[pallet::config]
 	pub trait Config: frame_system::Config {
 		type CurrencyId;
 		type Balance;
-		type SellRatio;
+		type Ratio;
 		type OrderId;
 		type OrderDetails;
 	}
@@ -31,17 +31,17 @@ pub mod pallet {
 					T::CurrencyId,
 					T::CurrencyId,
 					T::Balance,
-					T::SellRatio,
+					OrderRatio<T::Ratio>,
 				) -> Result<T::OrderId, DispatchError>
 				+ 'static,
 		) {
 			register_call!(move |(a, b, c, d, e)| f(a, b, c, d, e));
 		}
 
 		pub fn mock_update_order(
-			f: impl Fn(T::AccountId, T::OrderId, T::Balance, T::SellRatio) -> DispatchResult + 'static,
+			f: impl Fn(T::OrderId, T::Balance, OrderRatio<T::Ratio>) -> DispatchResult + 'static,
 		) {
-			register_call!(move |(a, b, c, d)| f(a, b, c, d));
+			register_call!(move |(a, b, c)| f(a, b, c));
 		}
 
 		pub fn mock_cancel_order(f: impl Fn(T::OrderId) -> DispatchResult + 'static) {
@@ -61,48 +61,58 @@ pub mod pallet {
 		pub fn mock_get_order_details(f: impl Fn(T::OrderId) -> Option<T::OrderDetails> + 'static) {
 			register_call!(f);
 		}
+
+		pub fn mock_convert_by_market(
+			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> TokenSwaps<T::AccountId> for Pallet<T> {
 		type Balance = T::Balance;
 		type CurrencyId = T::CurrencyId;
 		type OrderDetails = T::OrderDetails;
 		type OrderId = T::OrderId;
-		type SellRatio = T::SellRatio;
+		type Ratio = T::Ratio;
 
 		fn place_order(
 			a: T::AccountId,
 			b: Self::CurrencyId,
 			c: Self::CurrencyId,
 			d: Self::Balance,
-			e: Self::SellRatio,
+			e: OrderRatio<Self::Ratio>,
 		) -> Result<Self::OrderId, DispatchError> {
 			execute_call!((a, b, c, d, e))
 		}
 
 		fn update_order(
-			a: T::AccountId,
-			b: Self::OrderId,
-			c: Self::Balance,
-			d: Self::SellRatio,
+			a: Self::OrderId,
+			b: Self::Balance,
+			c: OrderRatio<Self::Ratio>,
 		) -> DispatchResult {
-			execute_call!((a, b, c, d))
+			execute_call!((a, b, c))
 		}
 
 		fn cancel_order(a: Self::OrderId) -> DispatchResult {
 			execute_call!(a)
 		}
 
-		fn is_active(a: Self::OrderId) -> bool {
-			execute_call!(a)
-		}
-
 		fn valid_pair(a: Self::CurrencyId, b: Self::CurrencyId) -> bool {
 			execute_call!((a, b))
 		}
 
 		fn get_order_details(a: Self::OrderId) -> Option<Self::OrderDetails> {
 			execute_call!(a)
 		}
+
+		fn convert_by_market(
+			a: Self::CurrencyId,
+			b: Self::CurrencyId,
+			c: Self::Balance,
+		) -> Result<Self::Balance, DispatchError> {
+			execute_call!((a, b, c))
+		}
 	}
 }

libs/traits/src/benchmarking.rs

@@ -52,81 +52,6 @@ pub trait InvestmentIdBenchmarkHelper {
 	fn bench_default_investment_id(pool_id: Self::PoolId) -> Self::InvestmentId;
 }
 
-/// Benchmark utility for adding currency trading pairs
-pub trait OrderBookBenchmarkHelper {
-	type AccountId;
-	type Balance;
-	type CurrencyId;
-	type OrderIdNonce;
-
-	/// Adds the corresponding trading pair, creates trader accounts and mints
-	/// appropriate amounts of balance into these
-	fn bench_setup_trading_pair(
-		asset_in: Self::CurrencyId,
-		asset_out: Self::CurrencyId,
-		amount_in: Self::Balance,
-		amount_out: Self::Balance,
-		decimals_in: u32,
-		decimals_out: u32,
-	) -> (Self::AccountId, Self::AccountId);
-
-	/// Fulfills the given swap order from the trader account
-	fn bench_fill_order_full(trader: Self::AccountId, order_id: Self::OrderIdNonce);
-}
-
-/// A representation of information helpful when doing a foreign investment
-/// benchmark setup.
-pub struct BenchForeignInvestmentSetupInfo<AccountId, InvestmentId, CurrencyId> {
-	/// The substrate investor address
-	pub investor: AccountId,
-	/// The investment id
-	pub investment_id: InvestmentId,
-	/// The pool currency which eventually will be invested
-	pub pool_currency: CurrencyId,
-	/// The foreign currency which shall be invested and thus swapped into pool
-	/// currency beforehand
-	pub foreign_currency: CurrencyId,
-	/// Bidirectionally funded to fulfill token swap orders
-	pub funded_trader: AccountId,
-}
-
-/// Benchmark utility for updating/collecting foreign investments and
-/// redemptions.
-
-pub trait ForeignInvestmentBenchmarkHelper {
-	type AccountId;
-	type Balance;
-	type CurrencyId;
-	type InvestmentId;
-
-	/// Perform necessary setup to enable an investor to invest with or redeem
-	/// into a foreign currency.
-	///
-	/// Returns
-	///  * The substrate investor address
-	///  * The investment id
-	///  * The pool currency id
-	///  * The foreign currency id
-	///  * A trading account which can bidirectionally fulfill swap orders for
-	///    the (foreign, pool) currency pair
-	fn bench_prepare_foreign_investments_setup(
-	) -> BenchForeignInvestmentSetupInfo<Self::AccountId, Self::InvestmentId, Self::CurrencyId>;
-
-	/// Perform necessary setup to prepare for the worst benchmark case by
-	/// calling just a single subsequent function.
-	///
-	/// NOTE: For the time being, the worst case should be collecting a
-	/// redemption when there is an active invest swap from foreign to pool. The
-	/// redemption collection will initiate a swap from pool to foreign such
-	/// that there is a swap merge conflict to be resolved.
-	fn bench_prep_foreign_investments_worst_case(
-		investor: Self::AccountId,
-		investment_id: Self::InvestmentId,
-		foreign_currency: Self::CurrencyId,
-		pool_currency: Self::CurrencyId,
-	);
-}
-
 /// Benchmark utility for adding pool fees
 pub trait PoolFeesBenchmarkHelper {
 	type PoolFeeInfo: Encode + Decode + Clone + TypeInfo + Debug;

libs/traits/src/lib.rs

@@ -503,98 +503,35 @@ pub trait CurrencyInspect {
 	fn is_tranche_token(currency: Self::CurrencyId) -> bool;
 }
 
+/// Determines an order price
+#[derive(Clone, Copy, Debug, Encode, Decode, Eq, PartialEq, MaxEncodedLen, TypeInfo)]
+pub enum OrderRatio<Ratio> {
+	Market,
+	Custom(Ratio),
+}
+
 pub trait TokenSwaps<Account> {
 	type CurrencyId;
 	type Balance;
-	type SellRatio;
+	type Ratio;
 	type OrderId;
 	type OrderDetails;
 
-	/// Swap tokens buying a `buy_amount` of `currency_in` using the
-	/// `currency_out` tokens. The implementer of this method should know
-	/// the current market rate between those two currencies.
-	/// `sell_rate_limit` defines the highest price acceptable for
-	/// `currency_in` currency when buying with `currency_out`. This
-	/// protects order placer if market changes unfavourably for swap order.
-	/// For example, with a `sell_rate_limit` of `3/2`, one `asset_in`
-	/// should never cost more than 1.5 units of `asset_out`. Returns `Result`
-	/// with `OrderId` upon successful order creation.
-	///
-	/// NOTE: The minimum fulfillment amount is implicitly set by the
-	/// implementor.
-	///
-	/// Example usage with `pallet_order_book` impl:
-	/// ```ignore
-	/// OrderBook::place_order(
-	///     {AccountId},
-	///     CurrencyId::ForeignAsset(0),
-	///     CurrencyId::ForeignAsset(1),
-	///     100 * FOREIGN_ASSET_0_DECIMALS,
-	///     Quantity::checked_from_rational(3u32, 2u32).unwrap(),
-	///     100 * FOREIGN_ASSET_0_DECIMALS
-	/// )
-	/// ```
-	/// Would return `Ok({OrderId}` and create the following order in storage:
-	/// ```ignore
-	/// Order {
-	///     order_id: {OrderId},
-	///     placing_account: {AccountId},
-	///     asset_in_id: CurrencyId::ForeignAsset(0),
-	///     asset_out_id: CurrencyId::ForeignAsset(1),
-	///     buy_amount: 100 * FOREIGN_ASSET_0_DECIMALS,
-	///     initial_buy_amount: 100 * FOREIGN_ASSET_0_DECIMALS,
-	///     sell_rate_limit: Quantity::checked_from_rational(3u32, 2u32).unwrap(),
-	///     max_sell_amount: 150 * FOREIGN_ASSET_1_DECIMALS,
-	///     min_fulfillment_amount: 10 * CFG * FOREIGN_ASSET_0_DECIMALS,
-	/// }
-	/// ```
+	/// Swap tokens selling `amount_out` of `currency_out` and buying
+	/// `currency_in` given an order ratio.
 	fn place_order(
 		account: Account,
 		currency_in: Self::CurrencyId,
 		currency_out: Self::CurrencyId,
-		buy_amount: Self::Balance,
-		sell_rate_limit: Self::SellRatio,
+		amount_out: Self::Balance,
+		ratio: OrderRatio<Self::Ratio>,
 	) -> Result<Self::OrderId, DispatchError>;
 
 	/// Update an existing active order.
-	/// As with creating an order, the `sell_rate_limit` defines the highest
-	/// price acceptable for `currency_in` currency when buying with
-	/// `currency_out`. Returns a Dispatch result.
-	///
-	/// NOTE: The minimum fulfillment amount is implicitly set by the
-	/// implementor.
-	///
-	/// This Can fail for various reasons.
-	///
-	/// Example usage with `pallet_order_book` impl:
-	/// ```ignore
-	/// OrderBook::update_order(
-	///     {AccountId},
-	///     {OrderId},
-	///     15 * FOREIGN_ASSET_0_DECIMALS,
-	///     Quantity::checked_from_integer(2u32).unwrap(),
-	///     6 * FOREIGN_ASSET_0_DECIMALS
-	/// )
-	/// ```
-	/// Would return `Ok(())` and update the following order in storage:
-	/// ```ignore
-	/// Order {
-	///     order_id: {OrderId},
-	///     placing_account: {AccountId},
-	///     asset_in_id: CurrencyId::ForeignAsset(0),
-	///     asset_out_id: CurrencyId::ForeignAsset(1),
-	///     buy_amount: 15 * FOREIGN_ASSET_0_DECIMALS,
-	///     initial_buy_amount: 100 * FOREIGN_ASSET_0_DECIMALS,
-	///     sell_rate_limit: Quantity::checked_from_integer(2u32).unwrap(),
-	///     max_sell_amount: 30 * FOREIGN_ASSET_1_DECIMALS
-	///     min_fulfillment_amount: 10 * CFG * FOREIGN_ASSET_0_DECIMALS,
-	/// }
-	/// ```
 	fn update_order(
-		account: Account,
 		order_id: Self::OrderId,
-		buy_amount: Self::Balance,
-		sell_rate_limit: Self::SellRatio,
+		amount_out: Self::Balance,
+		ratio: OrderRatio<Self::Ratio>,
 	) -> DispatchResult;
 
 	/// A sanity check that can be used for validating that a trading pair
@@ -605,11 +542,16 @@ pub trait TokenSwaps<Account> {
 	/// Cancel an already active order.
 	fn cancel_order(order: Self::OrderId) -> DispatchResult;
 
-	/// Check if the order is still active.
-	fn is_active(order: Self::OrderId) -> bool;
-
 	/// Retrieve the details of the order if it exists.
 	fn get_order_details(order: Self::OrderId) -> Option<Self::OrderDetails>;
+
+	/// Makes a conversion between 2 currencies using the market ratio between
+	/// them
+	fn convert_by_market(
+		currency_in: Self::CurrencyId,
+		currency_out: Self::CurrencyId,
+		amount_out: Self::Balance,
+	) -> Result<Self::Balance, DispatchError>;
 }
 
 /// Trait to transmit a change of status for anything uniquely identifiable.