add runtime api

Author: cocoyoon

pallets/hybrid-orderbook/ops/src/lib.rs

@@ -156,6 +156,7 @@ pub mod pallet {
             let pool_id = T::PoolLocator::pool_id(&asset1, &asset2)
                 .map_err(|_| Error::<T>::InvalidAssetPair)?;
             let info = Pools::<T>::get(&pool_id).ok_or(Error::<T>::PoolNotFound)?;
+            let metadata = PoolMetadata::<T>::get(&pool_id).ok_or(Error::<T>::PoolNotFound)?;
 
             let (prior_account, new_account) =
                 Self::addresses(&pool_id).ok_or(Error::<T>::InvalidAssetPair)?;
@@ -165,7 +166,7 @@ pub mod pallet {
             // Assets that must be transferred to the new account id.
             let balance1 = T::Assets::total_balance(asset1.clone(), &prior_account);
             let balance2 = T::Assets::total_balance(asset2.clone(), &prior_account);
-            let lp_balance = T::PoolAssets::total_balance(info.lp_token(), &prior_account);
+            let lp_balance = T::PoolAssets::total_balance(metadata.lp_token(), &prior_account);
 
             ensure!(!balance1.is_zero(), Error::<T>::ZeroBalance);
             ensure!(!balance2.is_zero(), Error::<T>::ZeroBalance);

pallets/hybrid-orderbook/src/lib.rs

@@ -237,18 +237,6 @@ pub mod pallet {
     #[pallet::storage]
     pub type NextPoolAssetId<T: Config> = StorageValue<_, T::PoolAssetId, OptionQuery>;
 
-    /// Stores the `Hold` assets for limit order
-    #[pallet::storage]
-    pub type FrozenAssets<T: Config> = StorageDoubleMap<
-        _,
-        Twox64Concat,
-        T::AccountId,
-        Twox64Concat,
-        T::AssetKind,
-        T::Unit,
-        OptionQuery,
-    >;
-
     // Pallet's events.
     #[pallet::event]
     #[pallet::generate_deposit(pub(super) fn deposit_event)]
@@ -530,9 +518,10 @@ pub mod pallet {
                 T::PoolAssets::touch(lp_token.clone(), &pool_account, &sender)?
             };
 
-            let pool = Pool::<T>::new(lp_token.clone(), taker_fee_rate, tick_size, lot_size);
-            Pools::<T>::insert(pool_id.clone(), pool);
-
+            Pools::<T>::insert(
+                pool_id.clone(),
+                Pool::<T>::new(lp_token.clone(), taker_fee_rate, tick_size, lot_size),
+            );
             Self::deposit_event(Event::PoolCreated {
                 creator: sender,
                 pool_id,
@@ -942,15 +931,11 @@ pub mod pallet {
                 // quote asset would be released.
                 let released = if is_bid { q } else { p * q };
                 // 1. Release the frozen asset
-                FrozenAssets::<T>::try_mutate(
-                    &owner,
+                T::AssetsFreezer::decrease_frozen(
                     asset1.clone(),
-                    |maybe_balance| -> DispatchResult {
-                        let mut new = maybe_balance.take().ok_or(Error::<T>::NoOps)?;
-                        new = new.saturating_sub(released);
-                        *maybe_balance = Some(new);
-                        Ok(())
-                    },
+                    &FreezeReason::LimitOrder.into(),
+                    &owner,
+                    released,
                 )?;
                 // 2. Transfer assets between orderer and owner of limit order
                 let (transfer1, transfer2) = if is_bid { (q, released) } else { (released, q) };
@@ -1294,7 +1279,7 @@ pub mod pallet {
         /// Pool price
         ///
         /// 1 * quote_reserve / base_reserve
-        pub(crate) fn pool_price(
+        pub fn pool_price(
             base_asset: &T::AssetKind,
             quote_asset: &T::AssetKind,
         ) -> Result<T::Unit, Error<T>> {
@@ -2002,7 +1987,7 @@ pub mod pallet {
 sp_api::decl_runtime_apis! {
     /// This runtime api allows people to query the size of the liquidity pools
     /// and quote prices for swaps.
-    pub trait AssetConversionApi<Balance, AssetId>
+    pub trait HybridOrderbookApi<Balance, AssetId>
     where
         Balance: frame_support::traits::tokens::Balance + MaybeDisplay,
         AssetId: Codec,
@@ -2031,6 +2016,9 @@ sp_api::decl_runtime_apis! {
 
         /// Returns the size of the liquidity pool for the given asset pair.
         fn get_reserves(asset1: AssetId, asset2: AssetId) -> Option<(Balance, Balance)>;
+
+        /// Returns the price of the given asset pair.
+        fn get_pool_price(base: AssetId, quote: AssetId) -> Option<Balance>;
     }
 }
 

pallets/hybrid-orderbook/src/types.rs

@@ -98,13 +98,13 @@ impl OrderbookOrderId for OrderId {
 
     fn new(is_bid: bool) -> Self {
         if is_bid {
-            Self::start_ask_id()
-        } else {
             Self::start_bid_id()
+        } else {
+            Self::start_ask_id()
         }
     }
 
-    fn checked_increase(&self, is_bid: bool) -> Option<Self> {
+    fn checked_increase(&self) -> Option<Self> {
         self.increase_by_one()
     }
 
@@ -188,7 +188,7 @@ pub trait OrderbookOrderId:
     /// Create new instance of `OrderId`
     fn new(is_bid: bool) -> Self;
     /// Increase `OrderId` by 1. Return `None`, if overflow
-    fn checked_increase(&self, is_bid: bool) -> Option<Self>;
+    fn checked_increase(&self) -> Option<Self>;
     /// Check whether it is id of `bid` order
     fn is_bid(&self) -> bool;
 }
@@ -283,7 +283,7 @@ impl<Quantity, Account: Clone, BlockNumber> Order<Quantity, Account, BlockNumber
 #[derive(Encode, Decode, Default, Debug, Clone, PartialEq, TypeInfo)]
 #[scale_info(skip_type_params(T))]
 pub struct Pool<T: Config> {
-    /// Liquidity pool asset
+    /// Id of lp token
     pub lp_token: T::PoolAssetId,
     /// The orderbook of the bid.
     pub bids: T::OrderBook,
@@ -340,13 +340,13 @@ impl<T: Config> Pool<T> {
 
     pub fn next_bid_order_id(&mut self) -> Result<OrderId, Error<T>> {
         let next = self.next_bid_order_id.clone();
-        self.next_bid_order_id = next.checked_increase(true).ok_or(Error::<T>::Overflow)?;
+        self.next_bid_order_id = next.checked_increase().ok_or(Error::<T>::Overflow)?;
         Ok(next)
     }
 
     pub fn next_ask_order_id(&mut self) -> Result<OrderId, Error<T>> {
         let next = self.next_ask_order_id.clone();
-        self.next_ask_order_id = next.checked_increase(false).ok_or(Error::<T>::Overflow)?;
+        self.next_ask_order_id = next.checked_increase().ok_or(Error::<T>::Overflow)?;
         Ok(next)
     }
 

runtime/src/apis.rs

@@ -27,6 +27,7 @@
 use alloc::vec::Vec;
 use frame_support::{
     genesis_builder_helper::{build_state, get_preset},
+    traits::fungible::NativeOrWithId,
     weights::Weight,
 };
 use pallet_aura::Authorities;
@@ -42,9 +43,9 @@ use sp_version::RuntimeVersion;
 
 // Local module imports
 use super::{
-    AccountId, Balance, Block, ConsensusHook, Executive, InherentDataExt, Nonce, ParachainSystem,
-    Runtime, RuntimeCall, RuntimeGenesisConfig, SessionKeys, System, TransactionPayment,
-    SLOT_DURATION, VERSION,
+    AccountId, Balance, Block, ConsensusHook, Executive, HybridOrderbook, InherentDataExt, Nonce,
+    ParachainSystem, Runtime, RuntimeCall, RuntimeGenesisConfig, SessionKeys, System,
+    TransactionPayment, SLOT_DURATION, VERSION,
 };
 
 // we move some impls outside so we can easily use them with `docify`.
@@ -210,6 +211,24 @@ impl_runtime_apis! {
         }
     }
 
+    impl pallet_hybrid_orderbook::HybridOrderbookApi<Block, Balance, NativeOrWithId<u32>> for Runtime {
+        fn quote_price_exact_tokens_for_tokens(asset1: NativeOrWithId<u32>, asset2: NativeOrWithId<u32>, amount: Balance, include_fee: bool) -> Option<Balance> {
+            HybridOrderbook::quote_price_exact_tokens_for_tokens(asset1, asset2, amount, include_fee)
+        }
+
+        fn quote_price_tokens_for_exact_tokens(asset1: NativeOrWithId<u32>, asset2: NativeOrWithId<u32>, amount: Balance, include_fee: bool) -> Option<Balance> {
+            HybridOrderbook::quote_price_tokens_for_exact_tokens(asset1, asset2, amount, include_fee)
+        }
+
+        fn get_reserves(asset1: NativeOrWithId<u32>, asset2: NativeOrWithId<u32>) -> Option<(Balance, Balance)> {
+            HybridOrderbook::get_reserves(&asset1, &asset2).ok()
+        }
+
+        fn get_pool_price(base: NativeOrWithId<u32>, quote: NativeOrWithId<u32>) -> Option<Balance> {
+            HybridOrderbook::pool_price(&base, &quote).ok()
+        }
+    }
+
     impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {
         fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {
             ParachainSystem::collect_collation_info(header)

runtime/src/lib.rs

@@ -16,7 +16,7 @@ extern crate alloc;
 use alloc::vec::Vec;
 use smallvec::smallvec;
 use sp_runtime::{
-    create_runtime_str, generic, impl_opaque_keys,
+    generic, impl_opaque_keys,
     traits::{BlakeTwo256, IdentifyAccount, Verify},
     MultiSignature,
 };
@@ -159,8 +159,8 @@ impl_opaque_keys! {
 
 #[sp_version::runtime_version]
 pub const VERSION: RuntimeVersion = RuntimeVersion {
-    spec_name: create_runtime_str!("warpx-runtime"),
-    impl_name: create_runtime_str!("warpx-runtime"),
+    spec_name: alloc::borrow::Cow::Borrowed("warpx-runtime"),
+    impl_name: alloc::borrow::Cow::Borrowed("warpx-runtime"),
     authoring_version: 1,
     spec_version: 1,
     impl_version: 0,