From feb71be8daa59d4f3e8784b52b1bcd70f0b9755b Mon Sep 17 00:00:00 2001 From: JanKuczma Date: Thu, 4 Jul 2024 13:10:31 +0200 Subject: [PATCH] setup drink tests structure --- amm/drink-tests/Cargo.lock | 1 + amm/drink-tests/Cargo.toml | 4 + amm/drink-tests/src/lib.rs | 2 - amm/drink-tests/src/rated_swap_tests.rs | 159 ---------- amm/drink-tests/src/stable_swap_tests.rs | 318 ------------------- amm/drink-tests/src/stable_swap_tests/mod.rs | 149 +++++++++ amm/drink-tests/src/utils.rs | 188 +++++++---- 7 files changed, 286 insertions(+), 535 deletions(-) delete mode 100644 amm/drink-tests/src/rated_swap_tests.rs delete mode 100644 amm/drink-tests/src/stable_swap_tests.rs create mode 100644 amm/drink-tests/src/stable_swap_tests/mod.rs diff --git a/amm/drink-tests/Cargo.lock b/amm/drink-tests/Cargo.lock index d7293e8..6fedd43 100644 --- a/amm/drink-tests/Cargo.lock +++ b/amm/drink-tests/Cargo.lock @@ -79,6 +79,7 @@ dependencies = [ "ink-wrapper-types", "ink_primitives", "parity-scale-codec", + "primitive-types", ] [[package]] diff --git a/amm/drink-tests/Cargo.toml b/amm/drink-tests/Cargo.toml index fa53f99..e0ea2e8 100644 --- a/amm/drink-tests/Cargo.toml +++ b/amm/drink-tests/Cargo.toml @@ -16,5 +16,9 @@ scale = { package = "parity-scale-codec", version = "3", default-features = fals "derive", ] } +primitive-types = { version = "0.12.1", default-features = false, features = [ + "codec", +] } + anyhow = "1.0.69" assert2 = "0.3.10" diff --git a/amm/drink-tests/src/lib.rs b/amm/drink-tests/src/lib.rs index c4957c3..0681550 100644 --- a/amm/drink-tests/src/lib.rs +++ b/amm/drink-tests/src/lib.rs @@ -1,8 +1,6 @@ #[cfg(test)] mod psp22; #[cfg(test)] -mod rated_swap_tests; -#[cfg(test)] #[allow(unused_imports)] mod mock_sazero_rate_contract; #[cfg(test)] diff --git a/amm/drink-tests/src/rated_swap_tests.rs b/amm/drink-tests/src/rated_swap_tests.rs deleted file mode 100644 index b56eb0b..0000000 --- a/amm/drink-tests/src/rated_swap_tests.rs +++ /dev/null @@ -1,159 +0,0 @@ -use crate::mock_sazero_rate_contract; -use crate::stable_pool_contract; -use crate::utils::*; - -use drink::{self, runtime::MinimalRuntime, session::Session}; -use ink_primitives::AccountId; -use ink_wrapper_types::{Connection, ToAccountId}; - -const SAZERO_DEC: u8 = 12; -const WAZERO_DEC: u8 = 12; - -const ONE_SAZERO: u128 = 10u128.pow(SAZERO_DEC as u32); -const ONE_AZERO: u128 = 10u128.pow(WAZERO_DEC as u32); - -const INIT_SUPPLY: u128 = 1_000_000; // 1M - -const TRADE_FEE_BPS: u16 = 6; -const PROTOCOL_FEE_BPS: u16 = 2000; - -const AMP_COEF: u128 = 1000; - -fn setup_rated_swap( - session: &mut Session, - sazero: AccountId, - wazero: AccountId, - init_amp_coef: u128, - rate_expiration_duration_ms: u64, - caller: drink::AccountId32, - trade_fee: u16, - protocol_fee: u16, - fee_receiver: Option, -) -> stable_pool_contract::Instance { - //upload and deploy rate mock - session - .upload_code(stable_pool_contract::upload()) - .expect("Upload stable_stable_pair_contract code"); - session - .upload_code(mock_sazero_rate_contract::upload()) - .expect("Upload sazero_rate_mock_contract code"); - let _ = session.set_actor(caller.clone()); - - let instance = mock_sazero_rate_contract::Instance::new(); - - let rate_mock_address = session - .instantiate(instance) - .unwrap() - .result - .to_account_id() - .into(); - let instance = stable_pool_contract::Instance::new_rated( - vec![sazero, wazero], - vec![SAZERO_DEC, WAZERO_DEC], - vec![Some(rate_mock_address), None], - rate_expiration_duration_ms, - init_amp_coef, - caller.to_account_id(), - trade_fee, - protocol_fee, - fee_receiver, - ); - - session - .instantiate(instance) - .unwrap() - .result - .to_account_id() - .into() -} - -fn setup_all( - session: &mut Session, -) -> (AccountId, AccountId, AccountId) { - upload_all(session); - - let wazero = psp22_utils::setup_with_amounts( - session, - "wAZERO".to_string(), - WAZERO_DEC, - INIT_SUPPLY * ONE_AZERO, - BOB, - ); - let sazero = psp22_utils::setup_with_amounts( - session, - "SAZERO".to_string(), - SAZERO_DEC, - INIT_SUPPLY * ONE_SAZERO, - BOB, - ); - let stable_pool_contract = setup_rated_swap( - session, - sazero.into(), - wazero.into(), - AMP_COEF, - 10000, //10 seconds rate cache expiration - BOB, - TRADE_FEE_BPS, - PROTOCOL_FEE_BPS, - Some(bob()), - ); - - for token in [sazero, wazero] { - psp22_utils::increase_allowance( - session, - token.into(), - stable_pool_contract.into(), - u128::MAX, - BOB, - ) - .unwrap(); - } - - (stable_pool_contract.into(), sazero.into(), wazero.into()) -} - -#[drink::test] -fn test_rated_1(mut session: Session) { - let one_minute: u64 = 60000; - let now = get_timestamp(&mut session); - set_timestamp(&mut session, now); - upload_all(&mut session); - let (rated_swap, sazero, wazero) = setup_all(&mut session); - _ = stable_swap::add_liquidity( - &mut session, - rated_swap.into(), - BOB, - 1, - vec![INIT_SUPPLY * ONE_SAZERO / 10, INIT_SUPPLY * ONE_AZERO / 10], - bob(), - ); - let amount = 10_000 * ONE_SAZERO; // 10k - - psp22_utils::increase_allowance( - &mut session, - sazero.into(), - rated_swap.into(), - u128::MAX, - BOB, - ) - .unwrap(); - - set_timestamp(&mut session, now + 10000 * one_minute); - _ = stable_swap::swap_exact_in( - &mut session, - rated_swap.into(), - BOB, - sazero.into(), - wazero.into(), - amount, - 1, // min_token_out - bob(), - ) - .result - .unwrap() - .unwrap_or_else(|_| panic!("Should return valid result")); - let reserves = stable_swap::reserves(&mut session, rated_swap.into()); - let balance_0 = psp22_utils::balance_of(&mut session, sazero.into(), rated_swap.into()); - let balance_1 = psp22_utils::balance_of(&mut session, wazero.into(), rated_swap.into()); - assert_eq!(reserves, vec![balance_0, balance_1]); -} diff --git a/amm/drink-tests/src/stable_swap_tests.rs b/amm/drink-tests/src/stable_swap_tests.rs deleted file mode 100644 index 2b61f7b..0000000 --- a/amm/drink-tests/src/stable_swap_tests.rs +++ /dev/null @@ -1,318 +0,0 @@ -use crate::stable_pool_contract::{self, StablePoolError}; -use crate::utils::*; - -use drink::{self, runtime::MinimalRuntime, session::Session}; -use ink_primitives::AccountId; -use ink_wrapper_types::{Connection, ToAccountId}; - -const FEE_BPS_DENOM: u128 = 10_000; - -fn setup_stable_swap( - session: &mut Session, - token_decimals: [u8; 2], - token_supply: [u128; 2], - amp_coef: u128, - fee_bps: u16, - protocol_fee_bps: u16, -) -> (AccountId, AccountId, AccountId) { - // (stable_pool, token_0, token_1) - let _ = session.set_actor(BOB); - upload_all(session); - session - .upload_code(stable_pool_contract::upload()) - .expect("Upload stable_pair_contract code"); - - // instantiate tokens - let token_0 = psp22_utils::setup_with_amounts( - session, - "token_0".to_string(), - token_decimals[0], - token_supply[0], - BOB, - ); - let token_1 = psp22_utils::setup_with_amounts( - session, - "token_1".to_string(), - token_decimals[1], - token_supply[1], - BOB, - ); - - // instantiate stable_swap - let instance = stable_pool_contract::Instance::new_stable( - vec![token_0.into(), token_1.into()], - token_decimals.to_vec(), - amp_coef, - bob(), - fee_bps, - protocol_fee_bps, - Some(charlie()), // fee receiver - ); - - let stable_swap: stable_pool_contract::Instance = session - .instantiate(instance) - .unwrap() - .result - .to_account_id() - .into(); - - // setup max allowance for stable swap contract on both tokens - for token in [token_0, token_1] { - psp22_utils::increase_allowance(session, token.into(), stable_swap.into(), u128::MAX, BOB) - .unwrap(); - } - - (stable_swap.into(), token_0.into(), token_1.into()) -} - -/// Tests swap of token at index 0 to token at index 1. -fn setup_test_swap_exact_in( - session: &mut Session, - token_decimals: [u8; 2], - initial_reserves: [u128; 2], - amp_coef: u128, - fee_bps: u16, - protocol_fee_bps: u16, - swap_amount_in: u128, - expected_swap_amount_out_total_result: Result, -) { - let initial_supply = [initial_reserves[0] + swap_amount_in, initial_reserves[1]]; - let (stable_swap, token_0, token_1) = setup_stable_swap( - session, - token_decimals, - initial_supply, - amp_coef, - fee_bps, - protocol_fee_bps, - ); - _ = stable_swap::add_liquidity( - session, - stable_swap, - BOB, - 1, - initial_reserves.to_vec(), - bob(), - ); - - let swap_result = stable_swap::swap_exact_in( - session, - stable_swap.into(), - BOB, - token_0, // in - token_1, // out - swap_amount_in, // amount_in - 0, // min_token_out - bob(), - ) - .result - .unwrap(); - - if expected_swap_amount_out_total_result.is_err() { - match swap_result { - Err(ref err) => { - let wrapped_error: Result = Err(err.clone()); - assert_eq!(expected_swap_amount_out_total_result, wrapped_error); - return; - } - Ok(val) => panic!("Should return an error. Return val: {val:?}"), - } - } - - let (amount_out, fee) = swap_result.unwrap(); - let expected_swap_amount_out_total = expected_swap_amount_out_total_result.unwrap(); - let expected_fee = expected_swap_amount_out_total * fee_bps as u128 / FEE_BPS_DENOM; - let expected_swap_amount_out = expected_swap_amount_out_total - expected_fee; - let expected_protocol_fee_part = expected_fee * protocol_fee_bps as u128 / FEE_BPS_DENOM; - - // check returned amount swapped and fee - assert_eq!(expected_swap_amount_out, amount_out, "Amount out mismatch"); - assert_eq!(expected_fee, fee, "Fee mismatch"); - - // check if reserves are equal the actual balances - let reserves = stable_swap::reserves(session, stable_swap.into()); - let balance_0 = psp22_utils::balance_of(session, token_0.into(), stable_swap.into()); - let balance_1 = psp22_utils::balance_of(session, token_1.into(), stable_swap.into()); - assert_eq!( - reserves, - vec![balance_0, balance_1], - "Balances - reserves mismatch" - ); - - // check bobs balances - let balance_0 = psp22_utils::balance_of(session, token_0.into(), bob()); - let balance_1 = psp22_utils::balance_of(session, token_1.into(), bob()); - assert_eq!( - [0, expected_swap_amount_out], - [balance_0, balance_1], - "Incorrect Bob's balances" - ); - - // check protocol fee - let protocol_fee_lp = psp22_utils::balance_of(session, stable_swap.into(), charlie()); - let (total_lp_required, lp_fee_part) = stable_swap::remove_liquidity_by_amounts( - session, - stable_swap.into(), - BOB, - protocol_fee_lp * 2, - [0, expected_protocol_fee_part].to_vec(), - bob(), - ) - .result - .unwrap() - .unwrap(); - assert_eq!( - total_lp_required - lp_fee_part, - protocol_fee_lp, - "Incorrect protocol fee" - ); -} - -// ref https://github.com/ref-finance/ref-contracts/blob/d241d7aeaa6250937b160d56e5c4b5b48d9d97f7/ref-exchange/src/stable_swap/mod.rs#L744 -#[drink::test] -fn test_stable_swap_exact_in_01(mut session: Session) { - setup_test_swap_exact_in( - &mut session, - [6, 6], // decimals - [100000000000, 100000000000], // initial reserves - 1000, // A - 6, // fee BPS - 2000, // protocol fee BPS - 10000000000, // swap_amount_in - Ok(9999495232), // expected out (with fee) - ); -} - -// ref https://github.com/ref-finance/ref-contracts/blob/d241d7aeaa6250937b160d56e5c4b5b48d9d97f7/ref-exchange/src/stable_swap/mod.rs#L763 -#[drink::test] -fn test_stable_swap_exact_in_02(mut session: Session) { - setup_test_swap_exact_in( - &mut session, - [12, 18], - [100000000000000000, 100000000000000000000000], - 1000, - 6, - 2000, - 10000000000000000, - Ok(9999495232752197989995), - ); -} - -// ref https://github.com/ref-finance/ref-contracts/blob/d241d7aeaa6250937b160d56e5c4b5b48d9d97f7/ref-exchange/src/stable_swap/mod.rs#L782 -#[drink::test] -fn test_stable_swap_exact_in_03(mut session: Session) { - setup_test_swap_exact_in( - &mut session, - [6, 6], - [100000000000, 100000000000], - 1000, - 6, - 2000, - 0, - Err(StablePoolError::InsufficientInputAmount()), - ); -} - -// ref https://github.com/ref-finance/ref-contracts/blob/d241d7aeaa6250937b160d56e5c4b5b48d9d97f7/ref-exchange/src/stable_swap/mod.rs#L801 -#[drink::test] -fn test_stable_swap_exact_in_04(mut session: Session) { - setup_test_swap_exact_in( - &mut session, - [12, 18], - [100000000000000000, 100000000000000000000000], - 1000, - 6, - 2000, - 0, - Err(StablePoolError::InsufficientInputAmount()), - ); -} - -// ref https://github.com/ref-finance/ref-contracts/blob/d241d7aeaa6250937b160d56e5c4b5b48d9d97f7/ref-exchange/src/stable_swap/mod.rs#L820 -#[drink::test] -fn test_stable_swap_exact_in_05(mut session: Session) { - setup_test_swap_exact_in( - &mut session, - [6, 6], - [100000000000, 100000000000], - 1000, - 6, - 2000, - 1, - Ok(0), - ); -} - -// ref https://github.com/ref-finance/ref-contracts/blob/d241d7aeaa6250937b160d56e5c4b5b48d9d97f7/ref-exchange/src/stable_swap/mod.rs#L839 -#[drink::test] -fn test_stable_swap_exact_in_06(mut session: Session) { - setup_test_swap_exact_in( - &mut session, - [18, 12], - [100000000000000000000000, 100000000000000000], - 1000, - 6, - 2000, - 1000000, - Ok(0), - ); -} - -// ref https://github.com/ref-finance/ref-contracts/blob/d241d7aeaa6250937b160d56e5c4b5b48d9d97f7/ref-exchange/src/stable_swap/mod.rs#L858 -#[drink::test] -fn test_stable_swap_exact_in_07(mut session: Session) { - setup_test_swap_exact_in( - &mut session, - [6, 6], - [100000000000, 100000000000], - 1000, - 6, - 2000, - 100000000000, - Ok(98443663539), - ); -} - -// ref https://github.com/ref-finance/ref-contracts/blob/d241d7aeaa6250937b160d56e5c4b5b48d9d97f7/ref-exchange/src/stable_swap/mod.rs#L877 -#[drink::test] -fn test_stable_swap_exact_in_08(mut session: Session) { - setup_test_swap_exact_in( - &mut session, - [12, 18], - [100000000000000000, 100000000000000000000000], - 1000, - 6, - 2000, - 100000000000000000, - Ok(98443663539913153080656), - ); -} - -// ref https://github.com/ref-finance/ref-contracts/blob/d241d7aeaa6250937b160d56e5c4b5b48d9d97f7/ref-exchange/src/stable_swap/mod.rs#L896 -#[drink::test] -fn test_stable_swap_exact_in_09(mut session: Session) { - setup_test_swap_exact_in( - &mut session, - [6, 6], - [100000000000, 100000000000], - 1000, - 6, - 2000, - 99999000000 + 1, // +1 because of accounting for fee rounding - Ok(98443167413), - ); -} - -// ref https://github.com/ref-finance/ref-contracts/blob/d241d7aeaa6250937b160d56e5c4b5b48d9d97f7/ref-exchange/src/stable_swap/mod.rs#L915 -#[drink::test] -fn test_stable_swap_exact_in_10(mut session: Session) { - setup_test_swap_exact_in( - &mut session, - [12, 18], - [100000000000000000, 100000000000000000000000], - 1000, - 6, - 2000, - 99999000000000000, - Ok(98443167413204135506296), - ); -} diff --git a/amm/drink-tests/src/stable_swap_tests/mod.rs b/amm/drink-tests/src/stable_swap_tests/mod.rs new file mode 100644 index 0000000..63c194c --- /dev/null +++ b/amm/drink-tests/src/stable_swap_tests/mod.rs @@ -0,0 +1,149 @@ +#[allow(dead_code)] +use crate::stable_pool_contract; +pub use crate::utils::*; +use primitive_types::U256; + +pub use stable_pool_contract::StablePool as _; +pub use stable_pool_contract::StablePoolError; +pub use stable_pool_contract::StablePoolView as _; + +use drink::{self, runtime::MinimalRuntime, session::Session, AccountId32}; + +use ink_primitives::AccountId; +use ink_wrapper_types::{Connection, ToAccountId}; + +pub const FEE_BPS_DENOM: u128 = 10_000; + +pub const RATE_PRECISION: u128 = 10u128.pow(12); + +pub const FEE_RECEIVER: AccountId32 = AccountId32::new([42u8; 32]); + +pub fn fee_receiver() -> ink_primitives::AccountId { + AsRef::<[u8; 32]>::as_ref(&FEE_RECEIVER).clone().into() +} + +pub const ONE_LPT: u128 = 1000000000000000000; +pub const ONE_DAI: u128 = 1000000000000000000; +pub const ONE_USDT: u128 = 1000000; +pub const ONE_USDC: u128 = 1000000; + +pub fn setup_stable_swap_with_tokens( + session: &mut Session, + token_decimals: Vec, + token_supply: Vec, + amp_coef: u128, + fee_bps: u16, + protocol_fee_bps: u16, + caller: AccountId32, +) -> (AccountId, Vec) { + let _ = session.set_actor(caller); + + if token_decimals.len() != token_supply.len() { + panic!("SETUP: Inconsistent number of tokens.") + } + + upload_all(session); + + // instantiate tokens + let tokens: Vec = token_decimals + .iter() + .zip(token_supply.iter()) + .enumerate() + .map(|(id, (&decimals, &supply))| { + psp22_utils::setup_with_amounts( + session, + format!("Test Token {id}").to_string(), + decimals, + supply, + BOB, + ) + .into() + }) + .collect::>(); + + // instantiate stable_swap + let instance = stable_pool_contract::Instance::new_stable( + tokens.clone(), + token_decimals, + amp_coef, + bob(), + fee_bps, + protocol_fee_bps, + Some(fee_receiver()), + ); + + let stable_swap: stable_pool_contract::Instance = session + .instantiate(instance) + .unwrap() + .result + .to_account_id() + .into(); + + // setup max allowance for stable swap contract on both tokens + for token in tokens.clone() { + psp22_utils::increase_allowance(session, token.into(), stable_swap.into(), u128::MAX, BOB) + .unwrap(); + } + + (stable_swap.into(), tokens) +} + +pub fn share_price_and_total_shares( + session: &mut Session, + stable_swap: AccountId, + token_rates: Option>, +) -> (u128, u128) { + let total_shares = psp22_utils::total_supply(session, stable_swap); + let reserves = stable_swap::reserves(session, stable_swap); + let token_rates: Vec = if let Some(rates) = token_rates { + rates + } else { + reserves.iter().map(|_| RATE_PRECISION).collect() + }; + let sum_token = stable_swap::tokens(session, stable_swap) + .iter() + .zip(reserves.iter()) + .zip(token_rates.iter()) + .fold(0, |acc, ((&token, reserve), rate)| { + acc + reserve + * 10u128.pow((18 - psp22_utils::token_decimals(session, token)).into()) + * rate + / RATE_PRECISION + }); + + ( + U256::from(sum_token) + .checked_mul(100000000.into()) + .unwrap() + .checked_div(total_shares.into()) + .unwrap_or(100000000.into()) + .as_u128(), + total_shares, + ) +} + +pub fn transfer_and_increase_allowance( + session: &mut Session, + stable_swap: AccountId, + tokens: Vec, + receiver: AccountId32, + amounts: Vec, + caller: AccountId32, +) { + for (&token, &amount) in tokens.iter().zip(amounts.iter()) { + _ = psp22_utils::transfer( + session, + token, + receiver.to_account_id(), + amount, + caller.clone(), + ); + _ = psp22_utils::increase_allowance( + session, + token, + stable_swap, + u128::MAX, + receiver.clone(), + ); + } +} diff --git a/amm/drink-tests/src/utils.rs b/amm/drink-tests/src/utils.rs index 46414d4..9ae4ab7 100644 --- a/amm/drink-tests/src/utils.rs +++ b/amm/drink-tests/src/utils.rs @@ -1,5 +1,4 @@ #![allow(dead_code)] -#![allow(unused_variables)] use crate::*; use anyhow::Result; @@ -9,6 +8,8 @@ use ink_wrapper_types::{Connection, ContractResult, InkLangError, ToAccountId}; pub const BOB: drink::AccountId32 = AccountId32::new([1u8; 32]); pub const CHARLIE: drink::AccountId32 = AccountId32::new([3u8; 32]); +pub const DAVE: drink::AccountId32 = AccountId32::new([4u8; 32]); +pub const EVA: drink::AccountId32 = AccountId32::new([5u8; 32]); pub const TOKEN: u128 = 10u128.pow(18); @@ -20,10 +21,31 @@ pub fn charlie() -> ink_primitives::AccountId { AsRef::<[u8; 32]>::as_ref(&CHARLIE).clone().into() } +pub fn dave() -> ink_primitives::AccountId { + AsRef::<[u8; 32]>::as_ref(&DAVE).clone().into() +} + +pub fn eva() -> ink_primitives::AccountId { + AsRef::<[u8; 32]>::as_ref(&EVA).clone().into() +} + +pub fn seed_account(session: &mut Session, account: AccountId32) { + session + .sandbox() + .mint_into(account, 1_000_000_000u128) + .unwrap(); +} + pub fn upload_all(session: &mut Session) { session .upload_code(stable_pool_contract::upload()) .expect("Upload stable_pool_contract code"); + session + .upload_code(mock_sazero_rate_contract::upload()) + .expect("Upload mock_rate_contract code"); + session + .upload_code(psp22::upload()) + .expect("Upload psp22 code"); } pub mod stable_swap { @@ -66,9 +88,9 @@ pub mod stable_swap { min_share_amount: u128, amounts: Vec, to: AccountId, - ) -> ContractResult, InkLangError>> { - let _ = session.set_actor(caller); - session + ) -> Result<(u128, u128), StablePoolError> { + _ = session.set_actor(caller); + handle_ink_error(session .execute( stable_pool_contract::Instance::from(stable_pool).add_liquidity( min_share_amount, @@ -76,7 +98,7 @@ pub mod stable_swap { to, ), ) - .unwrap() + .unwrap()) } pub fn remove_liquidity_by_amounts( @@ -86,9 +108,9 @@ pub mod stable_swap { max_share_amount: u128, amounts: Vec, to: AccountId, - ) -> ContractResult, InkLangError>> { - let _ = session.set_actor(caller); - session + ) -> Result<(u128, u128), StablePoolError> { + _ = session.set_actor(caller); + handle_ink_error(session .execute( stable_pool_contract::Instance::from(stable_pool).remove_liquidity_by_amounts( max_share_amount, @@ -96,7 +118,7 @@ pub mod stable_swap { to, ), ) - .unwrap() + .unwrap()) } pub fn remove_liquidity_by_shares( @@ -106,17 +128,19 @@ pub mod stable_swap { shares_amount: u128, min_amounts: Vec, to: AccountId, - ) -> ContractResult, StablePoolError>, InkLangError>> { - let _ = session.set_actor(caller); - session - .execute( - stable_pool_contract::Instance::from(stable_pool).remove_liquidity_by_shares( - shares_amount, - min_amounts, - to, - ), - ) - .unwrap() + ) -> Result, StablePoolError> { + _ = session.set_actor(caller); + handle_ink_error( + session + .execute( + stable_pool_contract::Instance::from(stable_pool).remove_liquidity_by_shares( + shares_amount, + min_amounts, + to, + ), + ) + .unwrap(), + ) } pub fn swap_exact_in( @@ -128,21 +152,21 @@ pub mod stable_swap { token_in_amount: u128, min_token_out_amount: u128, to: AccountId, - ) -> ContractResult< - Result, ink_wrapper_types::InkLangError>, - > { - let _ = session.set_actor(caller); - session - .execute( - stable_pool_contract::Instance::from(stable_pool).swap_exact_in( - token_in, - token_out, - token_in_amount, - min_token_out_amount, - to, - ), - ) - .unwrap() + ) -> Result<(u128, u128), StablePoolError> { + _ = session.set_actor(caller); + handle_ink_error( + session + .execute( + stable_pool_contract::Instance::from(stable_pool).swap_exact_in( + token_in, + token_out, + token_in_amount, + min_token_out_amount, + to, + ), + ) + .unwrap(), + ) } pub fn swap_exact_out( @@ -154,35 +178,83 @@ pub mod stable_swap { token_out_amount: u128, max_token_in_amount: u128, to: AccountId, - ) -> ContractResult< - Result, ink_wrapper_types::InkLangError>, - > { - let _ = session.set_actor(caller); - session - .execute( - stable_pool_contract::Instance::from(stable_pool).swap_exact_out( - token_in, - token_out, - token_out_amount, - max_token_in_amount, - to, - ), - ) - .unwrap() + ) -> Result<(u128, u128), StablePoolError> { + _ = session.set_actor(caller); + handle_ink_error( + session + .execute( + stable_pool_contract::Instance::from(stable_pool).swap_exact_out( + token_in, + token_out, + token_out_amount, + max_token_in_amount, + to, + ), + ) + .unwrap(), + ) + } + + pub fn swap_received( + session: &mut Session, + stable_pool: AccountId, + caller: drink::AccountId32, + token_in: AccountId, + token_out: AccountId, + min_token_out_amount: u128, + to: AccountId, + ) -> Result<(u128, u128), StablePoolError> { + _ = session.set_actor(caller); + handle_ink_error( + session + .execute( + stable_pool_contract::Instance::from(stable_pool).swap_received( + token_in, + token_out, + min_token_out_amount, + to, + ), + ) + .unwrap(), + ) } pub fn reserves(session: &mut Session, stable_pool: AccountId) -> Vec { - session - .query(stable_pool_contract::Instance::from(stable_pool).reserves()) - .unwrap() - .result - .unwrap() + handle_ink_error( + session + .query(stable_pool_contract::Instance::from(stable_pool).reserves()) + .unwrap(), + ) + } + + pub fn amp_coef(session: &mut Session, stable_pool: AccountId) -> u128 { + handle_ink_error( + session + .query(stable_pool_contract::Instance::from(stable_pool).amp_coef()) + .unwrap(), + ) + } + + pub fn fees(session: &mut Session, stable_pool: AccountId) -> (u16, u16) { + handle_ink_error( + session + .query(stable_pool_contract::Instance::from(stable_pool).fees()) + .unwrap(), + ) + } + + pub fn tokens(session: &mut Session, stable_pool: AccountId) -> Vec { + handle_ink_error( + session + .query(stable_pool_contract::Instance::from(stable_pool).tokens()) + .unwrap(), + ) } } pub mod psp22_utils { use super::*; - use psp22::{Instance as PSP22, PSP22 as _}; + use psp22::{Instance as PSP22, PSP22Metadata as _, PSP22 as _}; /// Uploads and creates a PSP22 instance with 1B*10^18 issuance and given names. /// Returns its AccountId casted to PSP22 interface. @@ -282,6 +354,10 @@ pub mod psp22_utils { pub fn total_supply(session: &mut Session, token: AccountId) -> u128 { handle_ink_error(session.query(PSP22::total_supply(&token.into())).unwrap()) } + + pub fn token_decimals(session: &mut Session, token: AccountId) -> u8 { + handle_ink_error(session.query(PSP22::token_decimals(&token.into())).unwrap()) + } } pub fn get_timestamp(session: &mut Session) -> u64 {