Skip to content

Commit

Permalink
Merge pull request #50 from mangata-finance/feature/xyk-wrap-storage
Browse files Browse the repository at this point in the history 
Feature/xyk wrap storage
  • Loading branch information
@gleb-urvanov
gleb-urvanov authored May 31, 2021
2 parents 9745892 + 097bdd8 commit 8a57a96
Show file tree
Hide file tree
Showing 4 changed files with 52 additions and 33 deletions.
1 change: 1 addition & 0 deletions pallets/staking/src/testing_utils.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -56,6 +56,7 @@ pub fn create_funded_user<T: Trait>(
liquidity_token_id.into(),
balance.into(),
)
.unwrap()
.into();

let first_asset_id: u32 = first_asset_id.into();
Expand Down
63 changes: 38 additions & 25 deletions pallets/xyk/src/lib.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -313,8 +313,8 @@ decl_storage! {

Pools get(fn asset_pool): map hasher(opaque_blake2_256) (TokenId, TokenId) => Balance;

LiquidityAssets get(fn liquidity_asset): map hasher(opaque_blake2_256) (TokenId, TokenId) => TokenId;
LiquidityPools get(fn liquidity_pool): map hasher(opaque_blake2_256) TokenId => (TokenId, TokenId);
LiquidityAssets get(fn liquidity_asset): map hasher(opaque_blake2_256) (TokenId, TokenId) => Option<TokenId>;
LiquidityPools get(fn liquidity_pool): map hasher(opaque_blake2_256) TokenId => Option<(TokenId, TokenId)>;
Treasury get(fn treasury): map hasher(opaque_blake2_256) TokenId => Balance;
TreasuryBurn get(fn treasury_burn): map hasher(opaque_blake2_256) TokenId => Balance;

Expand Down Expand Up @@ -475,11 +475,16 @@ impl<T: Trait> Module<T> {
result.saturated_into::<u128>().saturated_into::<Balance>()
}

pub fn get_liquidity_asset(first_asset_id: TokenId, second_asset_id: TokenId) -> TokenId {
pub fn get_liquidity_asset(
first_asset_id: TokenId,
second_asset_id: TokenId,
) -> Result<TokenId, DispatchError> {
if LiquidityAssets::contains_key((first_asset_id, second_asset_id)) {
LiquidityAssets::get((first_asset_id, second_asset_id))
.ok_or_else(|| Error::<T>::UnexpectedFailure.into())
} else {
LiquidityAssets::get((second_asset_id, first_asset_id))
.ok_or_else(|| Error::<T>::NoSuchPool.into())
}
}

Expand All @@ -488,9 +493,9 @@ impl<T: Trait> Module<T> {
first_asset_id: TokenId,
second_asset_id: TokenId,
liquidity_asset_amount: Balance,
) -> (Balance, Balance) {
) -> Result<(Balance, Balance), DispatchError> {
// Get token reserves and liquidity asset id
let liquidity_asset_id = Self::get_liquidity_asset(first_asset_id, second_asset_id);
let liquidity_asset_id = Self::get_liquidity_asset(first_asset_id, second_asset_id)?;
let first_asset_reserve_u256: U256 = Pools::get((first_asset_id, second_asset_id))
.saturated_into::<u128>()
.into();
Expand Down Expand Up @@ -518,7 +523,7 @@ impl<T: Trait> Module<T> {
.saturated_into::<u128>()
.saturated_into::<Balance>();

(first_asset_amount, second_asset_amount)
Ok((first_asset_amount, second_asset_amount))
}

//TODO U256?
Expand Down Expand Up @@ -692,12 +697,15 @@ pub trait XykFunctionsTrait<AccountId> {
fn get_tokens_required_for_minting(
liquidity_asset_id: Self::CurrencyId,
liquidity_token_amount: Self::Balance,
) -> (
Self::CurrencyId,
Self::Balance,
Self::CurrencyId,
Self::Balance,
);
) -> Result<
(
Self::CurrencyId,
Self::Balance,
Self::CurrencyId,
Self::Balance,
),
DispatchError,
>;
}

impl<T: Trait> XykFunctionsTrait<T::AccountId> for Module<T> {
Expand Down Expand Up @@ -990,7 +998,7 @@ impl<T: Trait> XykFunctionsTrait<T::AccountId> for Module<T> {
);

// Get liquidity token id
let liquidity_asset_id = Module::<T>::get_liquidity_asset(first_asset_id, second_asset_id);
let liquidity_asset_id = Module::<T>::get_liquidity_asset(first_asset_id, second_asset_id)?;

// Ensure pool exists
ensure!(
Expand Down Expand Up @@ -1107,7 +1115,7 @@ impl<T: Trait> XykFunctionsTrait<T::AccountId> for Module<T> {
// Get token reserves and liquidity asset id
let first_asset_reserve = Pools::get((first_asset_id, second_asset_id));
let second_asset_reserve = Pools::get((second_asset_id, first_asset_id));
let liquidity_asset_id = Module::<T>::get_liquidity_asset(first_asset_id, second_asset_id);
let liquidity_asset_id = Module::<T>::get_liquidity_asset(first_asset_id, second_asset_id)?;

// Ensure user has enought liquidity tokens to burn
ensure!(
Expand All @@ -1133,7 +1141,7 @@ impl<T: Trait> XykFunctionsTrait<T::AccountId> for Module<T> {

// Calculate first and second token amounts depending on liquidity amount to burn
let (first_asset_amount, second_asset_amount) =
Module::<T>::get_burn_amount(first_asset_id, second_asset_id, liquidity_asset_amount);
Module::<T>::get_burn_amount(first_asset_id, second_asset_id, liquidity_asset_amount)?;

let total_liquidity_assets: Balance =
T::Currency::total_issuance(liquidity_asset_id.into()).into();
Expand Down Expand Up @@ -1220,13 +1228,17 @@ impl<T: Trait> XykFunctionsTrait<T::AccountId> for Module<T> {
fn get_tokens_required_for_minting(
liquidity_asset_id: Self::CurrencyId,
liquidity_token_amount: Self::Balance,
) -> (
Self::CurrencyId,
Self::Balance,
Self::CurrencyId,
Self::Balance,
) {
let (first_asset_id, second_asset_id) = LiquidityPools::get(liquidity_asset_id);
) -> Result<
(
Self::CurrencyId,
Self::Balance,
Self::CurrencyId,
Self::Balance,
),
DispatchError,
> {
let (first_asset_id, second_asset_id) = LiquidityPools::get(liquidity_asset_id)
.ok_or_else(|| Error::<T>::NoSuchLiquidityAsset)?;
let first_asset_reserve = Pools::get((first_asset_id, second_asset_id));
let second_asset_reserve = Pools::get((second_asset_id, first_asset_id));
let total_liquidity_assets: Balance =
Expand All @@ -1253,12 +1265,12 @@ impl<T: Trait> XykFunctionsTrait<T::AccountId> for Module<T> {
.saturated_into::<u128>()
.saturated_into::<Balance>();

(
Ok((
first_asset_id,
first_asset_amount,
second_asset_id,
second_asset_amount,
)
))
}
}

Expand Down Expand Up @@ -1307,7 +1319,8 @@ impl<T: Trait> Valuate for Module<T> {
fn get_liquidity_token_mng_pool(
liquidity_token_id: Self::CurrencyId,
) -> Result<(Self::CurrencyId, Self::CurrencyId), DispatchError> {
let (first_token_id, second_token_id) = LiquidityPools::get(liquidity_token_id);
let (first_token_id, second_token_id) = LiquidityPools::get(liquidity_token_id)
.ok_or_else(|| Error::<T>::NoSuchLiquidityAsset)?;
let native_currency_id = T::NativeCurrencyId::get();
match native_currency_id {
_ if native_currency_id == first_token_id => Ok((first_token_id, second_token_id)),
Expand Down
8 changes: 4 additions & 4 deletions pallets/xyk/src/tests.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -287,8 +287,8 @@ fn multi() {
.unwrap();
assert_eq!(XykStorage::asset_pool((0, 1)), 1000000000000000000000000); // amount of asset 0 in pool map
assert_eq!(XykStorage::asset_pool((1, 0)), 500000000000000000000000); // amount of asset 1 in pool map
assert_eq!(XykStorage::liquidity_asset((0, 1)), 2); // liquidity assetId corresponding to newly created pool
assert_eq!(XykStorage::liquidity_pool(2), (0, 1)); // liquidity assetId corresponding to newly created pool
assert_eq!(XykStorage::liquidity_asset((0, 1)), Some(2)); // liquidity assetId corresponding to newly created pool
assert_eq!(XykStorage::liquidity_pool(2), Some((0, 1))); // liquidity assetId corresponding to newly created pool
assert_eq!(XykStorage::total_supply(2), 1500000000000000000000000); // total liquidity assets
assert_eq!(XykStorage::balance(2, 2), 1500000000000000000000000); // amount of liquidity assets owned by user by creating pool / initial minting
assert_eq!(XykStorage::balance(0, 2), 1000000000000000000000000); // amount of asset 0 in user acc after creating pool / initial minting
Expand Down Expand Up @@ -378,8 +378,8 @@ fn create_pool_W() {
initialize();
assert_eq!(XykStorage::asset_pool((0, 1)), 40000000000000000000); // amount of asset 0 in pool map
assert_eq!(XykStorage::asset_pool((1, 0)), 60000000000000000000); // amount of asset 1 in pool map
assert_eq!(XykStorage::liquidity_asset((0, 1)), 2); // liquidity assetId corresponding to newly created pool
assert_eq!(XykStorage::liquidity_pool(2), (0, 1)); // liquidity assetId corresponding to newly created pool
assert_eq!(XykStorage::liquidity_asset((0, 1)), Some(2)); // liquidity assetId corresponding to newly created pool
assert_eq!(XykStorage::liquidity_pool(2), Some((0, 1))); // liquidity assetId corresponding to newly created pool
assert_eq!(XykStorage::total_supply(2), 100000000000000000000); // total liquidity assets
assert_eq!(XykStorage::balance(2, 2), 100000000000000000000); // amount of liquidity assets owned by user by creating pool / initial minting
assert_eq!(XykStorage::balance(0, 2), 960000000000000000000); // amount of asset 0 in user acc after creating pool / initial minting
Expand Down
13 changes: 9 additions & 4 deletions runtime/src/lib.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -780,10 +780,15 @@ impl_runtime_apis! {
second_asset_id: TokenId,
liquidity_asset_amount: Balance
) -> RpcAmountsResult<Balance> {
let (first_asset_amount, second_asset_amount) = Xyk::get_burn_amount(first_asset_id, second_asset_id, liquidity_asset_amount);
RpcAmountsResult{
first_asset_amount,
second_asset_amount
match Xyk::get_burn_amount(first_asset_id, second_asset_id, liquidity_asset_amount){
Ok((first_asset_amount, second_asset_amount)) => RpcAmountsResult{
first_asset_amount,
second_asset_amount
},
Err(_) => RpcAmountsResult{
first_asset_amount: 0u32.into(),
second_asset_amount: 0u32.into()
},
}
}
}
Expand Down

0 comments on commit 8a57a96

Please sign in to comment.