create-dubhe 0.1.13 → 1.2.0-pre.51

package/templates/nextjs/sui-template/packages/contracts/src/dubhe/sources/tests/dex.move

@@ -0,0 +1,454 @@
+#[test_only]
+module dubhe::dex_tests {
+    use std::debug;
+    use std::u128;
+    use dubhe::dex_functions;
+    use dubhe::init_test::deploy_dapp_for_testing;
+    use dubhe::asset_pools;
+    use dubhe::dex_system;
+    use dubhe::assets_tests;
+    use dubhe::assets_system;
+    use dubhe::dapp_service::DappHub;
+    use sui::test_scenario;
+    use sui::test_scenario::Scenario;
+    use dubhe::dubhe_config;
+
+    public struct USDT has store, drop {  }
+
+    const DECIMAL: u256 = 1_000_000_000;
+
+    public fun init_test(): (DappHub, Scenario, address, address, address) {
+        let sender = @0xA;
+        let mut scenario = test_scenario::begin(sender);
+        let mut dapp_hub = deploy_dapp_for_testing(&mut scenario);
+        dubhe_config::set_next_asset_id(&mut dapp_hub, 0);
+
+        let name = b"Poils Coin";
+        let symbol = b"POL";
+        let description = b"";
+        let url = b"";
+        let decimals = 9;
+        let asset_0 = assets_tests::create_assets(&mut dapp_hub, name, symbol, description, decimals, url, &mut scenario);
+        let asset_1 = assets_tests::create_assets(&mut dapp_hub, name, symbol, description, decimals, url, &mut scenario);
+        let asset_2 = assets_tests::create_assets(&mut dapp_hub, name, symbol, description, decimals, url, &mut scenario);
+
+        (dapp_hub, scenario, asset_0, asset_1, asset_2)
+    }
+
+    #[test]
+    public fun check_max_number() {
+        let (mut dapp_hub, scenario, _, _, _) = init_test();
+        let u128_max = u128::max_value!() as u256;
+
+        dubhe_config::set_swap_fee(&mut dapp_hub, 0);
+
+        assert!(dex_functions::quote(3, u128_max, u128_max) ==  3);
+
+        let x = 1_000_000_000_000_000_000;
+        assert!(dex_functions::quote(10000_0000_0000 * x, 100_0000_0000_0000 * x, 100_0000_0000_0000 * x) == 10000_0000_0000 * x, 100);
+
+        assert!(dex_functions::quote(u128_max, u128_max, u128_max) == u128_max);
+
+        debug::print(&dex_functions::get_amount_out(&dapp_hub, 100, u128_max, u128_max));
+        assert!(dex_functions::get_amount_out(&dapp_hub, 100, u128_max, u128_max) == 99);
+        assert!(dex_functions::get_amount_in(&dapp_hub, 100, u128_max, u128_max) == 101);
+
+        dapp_hub.destroy();
+        scenario.end();
+    }
+
+    #[test]
+    public fun create_pool() {
+        let (mut dapp_hub, mut scenario, asset_0, asset_1, asset_2) = init_test();
+        
+        let pool_address = dex_functions::pair_for(asset_0, asset_1);
+        dex_system::create_pool(&mut dapp_hub, asset_0, asset_1);
+        std::debug::print(&asset_pools::get_struct(&dapp_hub, asset_0, asset_1));
+        assert!(pool_address == asset_pools::get_pool_address(&dapp_hub, asset_0, asset_1));
+
+        let pool_address = dex_functions::pair_for(asset_2, asset_1);
+        dex_system::create_pool(&mut dapp_hub, asset_1, asset_2);
+        std::debug::print(&asset_pools::get_struct(&dapp_hub, asset_2, asset_1));
+        assert!(asset_pools::get_pool_address(&dapp_hub, asset_2, asset_1) == pool_address);
+
+        dapp_hub.destroy();
+    
+        scenario.end();
+    }
+
+    #[test]
+    #[expected_failure]
+    public fun create_same_pool_twice_should_fail() {
+        let (mut dapp_hub, mut scenario, asset_0, asset_1, _) = init_test();
+
+        dex_system::create_pool(&mut dapp_hub, asset_0, asset_1);
+        dex_system::create_pool(&mut dapp_hub, asset_1, asset_0);
+
+        dapp_hub.destroy();
+    
+        scenario.end();
+    }
+
+    #[test]
+    public fun can_add_liquidity() {
+        let (mut dapp_hub, mut scenario, asset_0, asset_1, asset_2) = init_test();
+        dubhe_config::set_swap_fee(&mut dapp_hub, 30);
+        dubhe_config::set_fee_to(&mut dapp_hub, @0xfee);
+
+        let ctx =  test_scenario::ctx(&mut scenario);
+        dex_system::create_pool(&mut dapp_hub, asset_0, asset_1);
+        dex_system::create_pool(&mut dapp_hub, asset_1, asset_2);
+        dex_system::create_pool(&mut dapp_hub, asset_0, asset_2);
+
+        assets_system::mint(&mut dapp_hub, asset_0, ctx.sender(), 20000 * DECIMAL, ctx);
+        assets_system::mint(&mut dapp_hub, asset_1, ctx.sender(), 20000 * DECIMAL, ctx);
+        assets_system::mint(&mut dapp_hub, asset_2, ctx.sender(), 20000 * DECIMAL, ctx);
+
+        dex_system::add_liquidity(&mut dapp_hub, asset_0, asset_1, 10000 * DECIMAL, 10 * DECIMAL, 0, 0, ctx.sender(), ctx);
+        let pool = dex_functions::get_pool(&dapp_hub, asset_0, asset_1);
+        assert!(assets_system::balance_of(&dapp_hub, asset_0, ctx.sender()) == 20000 * DECIMAL - 10000 * DECIMAL);
+        assert!(assets_system::balance_of(&dapp_hub, asset_1, ctx.sender()) == 20000 * DECIMAL - 10 * DECIMAL);
+        assert!(assets_system::balance_of(&dapp_hub, asset_0, pool.pool_address()) == 10000 * DECIMAL);
+        assert!(assets_system::balance_of(&dapp_hub, asset_1, pool.pool_address()) == 10 * DECIMAL);
+
+        debug::print(&assets_system::balance_of(&dapp_hub, pool.lp_asset(), ctx.sender()));
+        std::debug::print(&dex_functions::get_pool(&dapp_hub, asset_0, asset_1));
+        // assert!(assets_system::balance_of(&mut dapp_hub, lp_asset_id, ctx.sender()) == 216 * DECIMAL, 0);
+
+        dex_system::add_liquidity(&mut dapp_hub, asset_1, asset_0, 2 * DECIMAL, 8000 * DECIMAL, 0, 0, ctx.sender(), ctx);
+        let pool = dex_functions::get_pool(&dapp_hub, asset_1, asset_0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_1, ctx.sender()) == 20000 * DECIMAL - 10 * DECIMAL - 2 * DECIMAL, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_0, ctx.sender()) == 20000 * DECIMAL - 10000 * DECIMAL - 2000 * DECIMAL, 0);
+        // assert!(assets_system::balance_of(&mut dapp_hub, lp_asset_id, ctx.sender()) == 216, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_0, pool.pool_address()) == 10000 * DECIMAL + 2000 * DECIMAL, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_1, pool.pool_address()) == 10 * DECIMAL + 2 * DECIMAL, 0);
+        debug::print(&assets_system::balance_of(&dapp_hub, pool.lp_asset(), ctx.sender()));
+        debug::print(&assets_system::balance_of(&dapp_hub, pool.lp_asset(), @0xfee));
+        std::debug::print(&dex_functions::get_pool(&dapp_hub, asset_0, asset_1));
+
+        dex_system::add_liquidity(&mut dapp_hub, asset_1, asset_0, 2 * DECIMAL, 8000 * DECIMAL, 0, 0, ctx.sender(), ctx);
+        // let (pool_address, lp_asset_id, _, _, _) = dex_functions::get_pool(&mut dapp_hub, asset_1, asset_0).get();
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_1, ctx.sender()) == 20000 * DECIMAL - 10 * DECIMAL - 2 * DECIMAL, 0);
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_0, ctx.sender()) == 20000 * DECIMAL - 10000 * DECIMAL - 2000 * DECIMAL, 0);
+        // // assert!(assets_system::balance_of(&mut dapp_hub, lp_asset_id, ctx.sender()) == 216, 0);
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_0, pool_address) == 10000 * DECIMAL + 2000 * DECIMAL, 0);
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_1, pool_address) == 10 * DECIMAL + 2 * DECIMAL, 0);
+        debug::print(&assets_system::balance_of(&dapp_hub, pool.lp_asset(), ctx.sender()));
+        debug::print(&assets_system::balance_of(&dapp_hub, pool.lp_asset(), @0xfee));
+        std::debug::print(&dex_functions::get_pool(&dapp_hub, asset_0, asset_1));
+
+
+        dex_system::add_liquidity(&mut dapp_hub, asset_1, asset_0, 2 * DECIMAL, 8000 * DECIMAL, 0, 0, ctx.sender(), ctx);
+        // let (pool_address, lp_asset_id, _, _, _) = dex_functions::get_pool(&mut dapp_hub, asset_1, asset_0).get();
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_1, ctx.sender()) == 20000 * DECIMAL - 10 * DECIMAL - 2 * DECIMAL, 0);
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_0, ctx.sender()) == 20000 * DECIMAL - 10000 * DECIMAL - 2000 * DECIMAL, 0);
+        // // assert!(assets_system::balance_of(&mut dapp_hub, lp_asset_id, ctx.sender()) == 216, 0);
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_0, pool_address) == 10000 * DECIMAL + 2000 * DECIMAL, 0);
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_1, pool_address) == 10 * DECIMAL + 2 * DECIMAL, 0);
+        debug::print(&assets_system::balance_of(&dapp_hub, pool.lp_asset(), ctx.sender()));
+        debug::print(&assets_system::balance_of(&dapp_hub, pool.lp_asset(), @0xfee));
+        std::debug::print(&dex_functions::get_pool(&dapp_hub, asset_0, asset_1));
+        
+
+        dapp_hub.destroy();
+    
+        scenario.end();
+    }
+
+    #[test]
+    public fun can_remove_liquidity() {
+        let (mut dapp_hub, mut scenario, asset_0, asset_1, asset_2) = init_test();
+        dubhe_config::set_swap_fee(&mut dapp_hub, 30);
+        dubhe_config::set_fee_to(&mut dapp_hub, @0xB);
+
+        let ctx =  test_scenario::ctx(&mut scenario);
+        dex_system::create_pool(&mut dapp_hub, asset_0, asset_1);
+        dex_system::create_pool(&mut dapp_hub, asset_1, asset_2);
+        dex_system::create_pool(&mut dapp_hub, asset_0, asset_2);
+
+        assets_system::mint(&mut dapp_hub, asset_0, ctx.sender(), 100000 * DECIMAL, ctx);
+        assets_system::mint(&mut dapp_hub, asset_1, ctx.sender(), 100000 * DECIMAL, ctx);
+        assets_system::mint(&mut dapp_hub, asset_2, ctx.sender(), 100000 * DECIMAL, ctx);
+
+        dex_system::add_liquidity(
+            &mut dapp_hub, 
+            asset_0, 
+            asset_1, 
+            100000 * DECIMAL, 
+            100000 * DECIMAL, 
+            100000 * DECIMAL, 
+            100000 * DECIMAL, 
+            ctx.sender(), 
+            ctx
+        );
+        let pool = dex_functions::get_pool(&dapp_hub, asset_0, asset_1);
+        let total_lp_received = assets_system::balance_of(&dapp_hub, pool.lp_asset(), ctx.sender());
+        // 99999999999000
+        debug::print(&total_lp_received);
+
+        dex_system::remove_liquidity(
+            &mut dapp_hub, 
+            asset_0, 
+            asset_1, 
+            total_lp_received / 2, 
+            0, 
+            0, 
+            ctx.sender(), 
+            ctx
+        );
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_0, ctx.sender()) == 10000000000 - 1000000000 + 899991000);
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_1, ctx.sender()) == 89999);
+    
+        std::debug::print(&assets_system::balance_of(&dapp_hub, asset_0, ctx.sender()));
+        std::debug::print(&assets_system::balance_of(&dapp_hub, asset_1, ctx.sender()));
+
+        // assert!(assets_system::balance_of(&mut dapp_hub, lp_asset_id, ctx.sender()) == 0, 0);
+        debug::print(&assets_system::balance_of(&dapp_hub, pool.lp_asset(), ctx.sender()));
+
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_0, pool_address) == 0, 0);
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_1, pool_address) == 0, 0);
+        // assert!(assets_system::balance_of(&mut dapp_hub, lp_asset_id, @0xB) == 999990, 0);
+        std::debug::print(&assets_system::balance_of(&dapp_hub, pool.lp_asset(), @0xB));
+        std::debug::print(&assets_system::balance_of(&dapp_hub, asset_0, pool.pool_address()));
+        std::debug::print(&assets_system::balance_of(&dapp_hub, asset_1, pool.pool_address()));
+
+        dex_system::remove_liquidity(
+            &mut dapp_hub, 
+            asset_0, 
+            asset_1, 
+            total_lp_received / 2, 
+            0, 
+            0, 
+            ctx.sender(), 
+            ctx
+        );
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_0, ctx.sender()) == 10000000000 - 1000000000 + 899991000);
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_1, ctx.sender()) == 89999);
+    
+        std::debug::print(&assets_system::balance_of(&dapp_hub, asset_0, ctx.sender()));
+        std::debug::print(&assets_system::balance_of(&dapp_hub, asset_1, ctx.sender()));
+
+        // assert!(assets_system::balance_of(&mut dapp_hub, lp_asset_id, ctx.sender()) == 0, 0);
+        debug::print(&assets_system::balance_of(&dapp_hub, pool.lp_asset(), ctx.sender()));
+
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_0, pool_address) == 0, 0);
+        // assert!(assets_system::balance_of(&mut dapp_hub, asset_1, pool_address) == 0, 0);
+        // assert!(assets_system::balance_of(&mut dapp_hub, lp_asset_id, @0xB) == 999990, 0);
+        std::debug::print(&assets_system::balance_of(&dapp_hub, pool.lp_asset(), @0xB));
+        std::debug::print(&assets_system::balance_of(&dapp_hub, asset_0, pool.pool_address()));
+        std::debug::print(&assets_system::balance_of(&dapp_hub, asset_1, pool.pool_address()));
+
+        dapp_hub.destroy();
+    
+        scenario.end();
+    }
+
+    #[test]
+    public fun can_swap() {
+        let (mut dapp_hub, mut scenario, asset_0, asset_1, asset_2) = init_test();
+        dubhe_config::set_swap_fee(&mut dapp_hub, 30);
+        dubhe_config::set_fee_to(&mut dapp_hub, @0xB);
+
+        let ctx =  test_scenario::ctx(&mut scenario);
+        dex_system::create_pool(&mut dapp_hub, asset_0, asset_1);
+        dex_system::create_pool(&mut dapp_hub, asset_1, asset_2);
+
+        assets_system::mint(&mut dapp_hub, asset_0, ctx.sender(), 10000 * DECIMAL, ctx);
+        assets_system::mint(&mut dapp_hub, asset_1, ctx.sender(), 1000 * DECIMAL, ctx);
+        assets_system::mint(&mut dapp_hub, asset_2, ctx.sender(), 100000 * DECIMAL, ctx);
+
+        let liquidity1 = 800 * DECIMAL;
+        let liquidity2 = 200 * DECIMAL;
+
+        dex_system::add_liquidity(&mut dapp_hub, asset_0, asset_1, liquidity1, liquidity2, 1, 1, ctx.sender(), ctx);
+
+        let input_amount = 10 * DECIMAL;
+        let expect_receive =
+            dex_system::get_amounts_out(&mut dapp_hub, input_amount, vector[asset_0, asset_1]);
+        debug::print(&expect_receive);
+
+        let balance0 = 10000 * DECIMAL - liquidity1 - input_amount;
+        let balance1 = 1000 * DECIMAL - liquidity2 + expect_receive[expect_receive.length() - 1];
+        dex_system::swap_exact_tokens_for_tokens(&mut dapp_hub, input_amount, 1, vector[asset_0, asset_1], ctx.sender(), ctx);
+        assert!(assets_system::balance_of(&dapp_hub, asset_0, ctx.sender()) == balance0, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_1, ctx.sender()) == balance1, 0);
+
+        let liquidity1 = liquidity1 + input_amount;
+        let liquidity2 = liquidity2 - expect_receive[expect_receive.length() - 1];
+        let pool_address = asset_pools::get_pool_address(&dapp_hub, asset_0, asset_1);
+        assert!(assets_system::balance_of(&dapp_hub, asset_0, pool_address) == liquidity1, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_1, pool_address) == liquidity2, 0);
+
+
+        let output_amount = 10 * DECIMAL;
+        let amounts =
+            dex_system::get_amounts_in(&mut dapp_hub, output_amount, vector[asset_1, asset_0]);
+        debug::print(&amounts);
+        dex_system::swap_tokens_for_exact_tokens(&mut dapp_hub, output_amount, amounts[0], vector[asset_1, asset_0], ctx.sender(), ctx);
+
+        let balance0 = balance0 + output_amount;
+        let balance1 = balance1 - amounts[0];
+
+        assert!(assets_system::balance_of(&dapp_hub, asset_0, ctx.sender()) == balance0, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_1, ctx.sender()) == balance1, 0);
+
+        let liquidity1 = liquidity1 - output_amount;
+        let liquidity2 = liquidity2 + amounts[0];
+        assert!(assets_system::balance_of(&dapp_hub, asset_0, pool_address) == liquidity1, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_1, pool_address) == liquidity2, 0);
+
+        std::debug::print(&dex_functions::get_pool(&dapp_hub, asset_0, asset_1));
+
+        dapp_hub.destroy();
+    
+        scenario.end();
+    }
+
+     #[test]
+    public fun can_multiple_swap() {
+        let (mut dapp_hub, mut scenario, asset_0, asset_1, asset_2) = init_test();
+        dubhe_config::set_swap_fee(&mut dapp_hub, 30);
+        dubhe_config::set_fee_to(&mut dapp_hub, @0xB);
+
+        let ctx =  test_scenario::ctx(&mut scenario);
+        dex_system::create_pool(&mut dapp_hub, asset_0, asset_1);
+        dex_system::create_pool(&mut dapp_hub, asset_1, asset_2);
+
+        assets_system::mint(&mut dapp_hub, asset_0, ctx.sender(), 10000 * DECIMAL, ctx);
+        assets_system::mint(&mut dapp_hub, asset_1, ctx.sender(), 1000 * DECIMAL, ctx);
+        assets_system::mint(&mut dapp_hub, asset_2, ctx.sender(), 100000 * DECIMAL, ctx);
+
+        let liquidity1 = 800 * DECIMAL;
+        let liquidity2 = 200 * DECIMAL;
+        let liquidity3 = 100 * DECIMAL;
+        let liquidity4 = 100 * DECIMAL;
+
+        dex_system::add_liquidity(&mut dapp_hub, asset_0, asset_1, liquidity1, liquidity2, 1, 1, ctx.sender(), ctx);
+        dex_system::add_liquidity(&mut dapp_hub, asset_1, asset_2, liquidity3, liquidity4, 1, 1, ctx.sender(), ctx);
+
+        let input_amount = 10 * DECIMAL;
+        let path = vector[asset_0, asset_1, asset_2];
+        let amounts =
+            dex_system::get_amounts_out(&mut dapp_hub, input_amount, path);
+        debug::print(&amounts);
+
+        let balance0 = 10000 * DECIMAL - liquidity1 - input_amount;
+        let balance1 = 1000 * DECIMAL - liquidity2 - liquidity3;
+        let balance2 = 100000 * DECIMAL - liquidity3 + amounts[amounts.length() - 1];
+
+        dex_system::swap_exact_tokens_for_tokens(&mut dapp_hub, input_amount, 1, path, ctx.sender(), ctx);
+        assert!(assets_system::balance_of(&dapp_hub, asset_0, ctx.sender()) == balance0, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_1, ctx.sender()) == balance1, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_2, ctx.sender()) == balance2, 0);
+
+        let liquidity1 = liquidity1 + input_amount;
+        let liquidity2 = liquidity2 - amounts[1];
+        let pool_address = asset_pools::get_pool_address(&dapp_hub, asset_0, asset_1);
+        assert!(assets_system::balance_of(&dapp_hub, asset_0, pool_address) == liquidity1, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_1, pool_address) == liquidity2, 0);
+        std::debug::print(&assets_system::balance_of(&dapp_hub, asset_0, pool_address));
+        std::debug::print(&assets_system::balance_of(&dapp_hub, asset_1, pool_address));
+
+        let liquidity3 = liquidity3 + amounts[1];
+        let liquidity4 = liquidity4 - amounts[2];
+        let pool_address = asset_pools::get_pool_address(&dapp_hub, asset_2, asset_1);
+        assert!(assets_system::balance_of(&dapp_hub, asset_1, pool_address) == liquidity3, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_2, pool_address) == liquidity4, 0);
+        std::debug::print(&assets_system::balance_of(&dapp_hub, asset_1, pool_address));
+        std::debug::print(&assets_system::balance_of(&dapp_hub, asset_2, pool_address));
+
+        let output_amount = 10 * DECIMAL;
+        let path = vector[asset_0, asset_1, asset_2];
+        let amounts =
+            dex_system::get_amounts_in(&mut dapp_hub, output_amount, path);
+        debug::print(&amounts);
+        dex_system::swap_tokens_for_exact_tokens(&mut dapp_hub, output_amount, amounts[0], path, ctx.sender(), ctx);
+
+        let balance0 = balance0 - amounts[0];
+        let balance1 = balance1;
+        let balance2 = balance2 + output_amount;
+
+        assert!(assets_system::balance_of(&dapp_hub, asset_0, ctx.sender()) == balance0, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_1, ctx.sender()) == balance1, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_2, ctx.sender()) == balance2, 0);
+
+        let liquidity1 = liquidity1 + amounts[0];
+        let liquidity2 = liquidity2 - amounts[1];
+        let pool_address = asset_pools::get_pool_address(&dapp_hub, asset_0, asset_1);
+        assert!(assets_system::balance_of(&dapp_hub, asset_0, pool_address) == liquidity1, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_1, pool_address) == liquidity2, 0);
+
+        let liquidity3 = liquidity3 + amounts[1];
+        let liquidity4 = liquidity4 - amounts[2];
+        let pool_address = asset_pools::get_pool_address(&dapp_hub, asset_2, asset_1);
+        assert!(assets_system::balance_of(&dapp_hub, asset_1, pool_address) == liquidity3, 0);
+        assert!(assets_system::balance_of(&dapp_hub, asset_2, pool_address) == liquidity4, 0);
+
+        std::debug::print(&dex_functions::get_pool(&dapp_hub, asset_0, asset_1));
+        std::debug::print(&dex_functions::get_pool(&dapp_hub, asset_1, asset_2));
+        dapp_hub.destroy();
+    
+        scenario.end();
+    }
+
+    // #[test]
+    // fun mock_swap() {
+    //     let (mut dapp_hub, mut scenario, asset_0, asset_1, _) = init_test();
+
+    //     let ctx = test_scenario::ctx(&mut scenario);
+    //   dex_system::create_pool(&mut dapp_hub, asset_0, asset_1, ctx);
+
+    //   assets_system::mint(&mut dapp_hub, asset_0, ctx.sender(), 10000 * DECIMAL, ctx);
+    //     assets_system::mint(&mut dapp_hub, asset_1, ctx.sender(), 1000 * DECIMAL, ctx);
+
+    //   dapp_hub.pools().set(asset_0, asset_1, dubhe_pool::new(
+    //         @0xcdbf6f09931206f105dbd759561f36aff7676f5eec7fe6e027473cea643250f7, 
+    //         2, 
+    //         3392173622 - 653980268 - 6524556,
+    //         80109881 - 15444457 - 154084, 
+    //         271746625189758982
+    //         )
+    //     );
+
+    //     dapp_hub.asset_metadata().set(asset_0, dubhe::asset_metadata::new(
+    //         std::ascii::string(b"USDT"),
+    //         std::ascii::string(b"USDT"),
+    //         std::ascii::string(b"USDT"),
+    //         9,
+    //         std::ascii::string(b""),
+    //         std::ascii::string(b""),
+    //         @0xcdbf6f09931206f105dbd759561f36aff7676f5eec7fe6e027473cea643250f7,
+    //         418696631,
+    //         0,
+    //         dubhe::asset_status::new_liquid(),
+    //         true,
+    //         true,
+    //         true,
+    //         dubhe::asset_type::new_lp()
+    //     ));
+
+    //     dapp_hub.account().set(asset_0, @0xcdbf6f09931206f105dbd759561f36aff7676f5eec7fe6e027473cea643250f7, dubhe::dubhe_account::new(
+    //        2738193354,
+    //         dubhe::account_status::new_liquid(),
+    //     ));
+
+    //     dapp_hub.account().set(asset_1, @0xcdbf6f09931206f105dbd759561f36aff7676f5eec7fe6e027473cea643250f7, dubhe::dubhe_account::new(
+    //         64665424,
+    //         dubhe::account_status::new_liquid(),
+    //     ));
+
+    //     dex_system::add_liquidity(
+    //         &mut dapp_hub, 
+    //         asset_0, 
+    //         asset_1, 
+    //         200000000, 
+    //         4723218, 
+    //         199000000, 
+    //         4699602, 
+    //         ctx.sender(), 
+    //         ctx
+    //     );
+    //     dapp_hub.destroy();
+    //     scenario.end();
+    // }
+}

package/templates/nextjs/sui-template/packages/contracts/src/dubhe/sources/tests/math.move

@@ -0,0 +1,12 @@
+#[test_only]
+module dubhe::math_tests {
+    use std::debug;
+    use dubhe::dubhe_math;
+
+    #[test]
+    public fun test_windows2()  {
+        debug::print(&dubhe_math::windows(&vector[1, 2, 3, 4, 5], 2));
+        debug::print(&dubhe_math::windows(&vector[1, 2, 3, 4, 5], 3));
+        debug::print(&dubhe_math::windows(&vector[1, 2], 2));
+    }
+}

package/templates/nextjs/sui-template/packages/contracts/src/dubhe/sources/tests/wrapper.move

@@ -0,0 +1,50 @@
+#[test_only]
+module dubhe::wrapper_tests {
+    use dubhe::init_test::deploy_dapp_for_testing;
+    use dubhe::assets_system;
+    use dubhe::wrapper_system;
+    use sui::test_scenario;
+    use sui::coin;
+    use sui::sui::SUI;
+    use dubhe::dubhe::DUBHE;
+
+    const SUI_ASSET_ID: address = @0x9d3670d0143ee414db420bc60b393df9e5c25ed1298408e4b6fa6873dfedae14;
+    const DUBHE_ASSET_ID: address = @0x4fb7f368a1f8a818847995e240d0d783fdf961afe15cfa208d4b25d65d2170af;
+
+    #[test]
+    public fun wrapper_tests() {
+         let sender = @0xA;
+        let mut scenario = test_scenario::begin(sender);
+        let mut dapp_hub = deploy_dapp_for_testing(&mut scenario);
+        
+        let ctx = test_scenario::ctx(&mut scenario);
+        let amount: u256 = 1000000;
+
+        let sui = coin::mint_for_testing<SUI>(amount as u64, ctx);
+        let beneficiary = ctx.sender();
+        wrapper_system::wrap(&mut dapp_hub, sui, beneficiary);
+        assert!(assets_system::balance_of(&dapp_hub, SUI_ASSET_ID, beneficiary) == amount);
+        assert!(assets_system::supply_of(&dapp_hub, SUI_ASSET_ID) == amount);
+
+        wrapper_system::unwrap<SUI>(&mut dapp_hub, amount, beneficiary, ctx);
+        assert!(assets_system::balance_of(&dapp_hub, SUI_ASSET_ID, beneficiary) == 0);
+
+        let sui = coin::mint_for_testing<SUI>(amount as u64, ctx);
+        wrapper_system::wrap(&mut dapp_hub, sui, beneficiary);
+        assert!(assets_system::balance_of(&dapp_hub, SUI_ASSET_ID, beneficiary) == amount);
+        assert!(assets_system::supply_of(&dapp_hub, SUI_ASSET_ID) == amount);
+
+        let dubhe = coin::mint_for_testing<DUBHE>(amount as u64, ctx);
+        wrapper_system::wrap(&mut dapp_hub, dubhe, beneficiary);
+        assert!(assets_system::balance_of(&dapp_hub, DUBHE_ASSET_ID, beneficiary) == amount);
+        assert!(assets_system::supply_of(&dapp_hub, DUBHE_ASSET_ID) == amount);
+
+        let dubhe = coin::mint_for_testing<DUBHE>(amount as u64, ctx);
+        wrapper_system::wrap(&mut dapp_hub, dubhe, beneficiary);
+        assert!(assets_system::balance_of(&dapp_hub, DUBHE_ASSET_ID, beneficiary) == amount * 2);
+        assert!(assets_system::supply_of(&dapp_hub, DUBHE_ASSET_ID) == amount * 2);
+
+        dapp_hub.destroy();
+        scenario.end();
+    }
+}

package/templates/nextjs/sui-template/packages/contracts/src/dubhe/sources/utils/math.move

@@ -0,0 +1,128 @@
+module dubhe::dubhe_math {
+    use std::u128;
+    use std::u64;
+
+    public fun min(x: u256, y: u256): u256 {
+        if (x < y) x else y
+    }
+
+    public fun safe_mul(a: u256, b: u256): u256 {
+        if (a == 0 || b == 0) return 0;
+        let c = a * b;
+        assert!(c / a == b, 0);
+        c
+    }
+
+    public fun safe_div(a: u256, b: u256): u256 {
+        assert!(b != 0, 0);
+        a / b
+    }
+
+    /// https://medium.com/coinmonks/math-in-solidity-part-3-percents-and-proportions-4db014e080b1
+    /// calculate x * y /z with as little loss of precision as possible and avoid overflow
+    public fun safe_mul_div(x: u256, y: u256, z: u256): u256 {
+        if (y == z) {
+            return x
+        };
+        if (x == z) {
+            return y
+        };
+        let a = x / z;
+        let b = x % z;
+        //x = a * z + b;
+        let c = y / z;
+        let d = y % z;
+        //y = c * z + d;
+        a * c * z + a * d + b * c + b * d / z
+    }
+
+    public fun log2_down(x: u256): u8 {
+        let mut x = x;
+        let mut result = 0;
+        if (x >> 128 > 0) {
+            x = x >> 128;
+            result = result + 128;
+        };
+
+        if (x >> 64 > 0) {
+            x = x >> 64;
+            result = result + 64;
+        };
+
+        if (x >> 32 > 0) {
+            x = x >> 32;
+            result = result + 32;
+        };
+
+        if (x >> 16 > 0) {
+            x = x >> 16;
+            result = result + 16;
+        };
+
+        if (x >> 8 > 0) {
+            x = x >> 8;
+            result = result + 8;
+        };
+
+        if (x >> 4 > 0) {
+            x = x >> 4;
+            result = result + 4;
+        };
+
+        if (x >> 2 > 0) {
+            x = x >> 2;
+            result = result + 2;
+        };
+
+        if (x >> 1 > 0)
+            result = result + 1;
+
+        result
+    }
+
+    public fun sqrt_down(x: u256): u256 {
+        if (x == 0) return 0;
+
+        let mut result = 1 << ((log2_down(x) >> 1) as u8);
+
+        result = (result + x / result) >> 1;
+        result = (result + x / result) >> 1;
+        result = (result + x / result) >> 1;
+        result = (result + x / result) >> 1;
+        result = (result + x / result) >> 1;
+        result = (result + x / result) >> 1;
+        result = (result + x / result) >> 1;
+
+        min(result, x / result)
+    }
+
+    /// support 18-bit precision token
+    /// if token is limited release, the total capacity around e10 (almost ten billions)
+    /// can avoid  sqrt(x*y) overflow, and at the same time avoid loss presicion
+    public fun safe_mul_sqrt(x: u256, y: u256): u256 {
+        if (x < (u128::max_value!() as u256) && y < (u128::max_value!() as u256)) {
+            sqrt_down(x * y)
+        } else {
+            sqrt_down(x) * sqrt_down(y)
+        }
+    }
+
+    public(package) fun windows(x: &vector<u256>, size: u64): vector<vector<u256>> {
+        assert!(size > 0, 0);
+
+        let length = vector::length(x);
+        let mut result = vector::empty<vector<u256>>();
+
+        let num_windows = length - size + 1;
+
+        u64::range_do!(0, num_windows, |i| {
+            let mut window = vector::empty<u256>();
+            u64::range_do!(0, size, |j| {
+                window.push_back(x[i + j]);
+            });
+            vector::push_back(&mut result, window);
+        });
+
+        result
+    }
+}

package/templates/nextjs/sui-template/packages/contracts/src/dubhe/sources/utils/type_info.move

@@ -0,0 +1,39 @@
+module dubhe::type_info {
+    use std::ascii::String;
+    use std::ascii::string;
+    use std::type_name;
+    use sui::address;
+    use std::type_name::TypeName;
+
+    public fun parse_type_name(type_name: TypeName): (address, String, String, String) {
+        let pending_parse_str = type_name.into_string();
+        let delimiter = string(b"::");
+
+        // TBD: this can probably be hard-coded as all hex addrs are 64 bytes
+        let package_delimiter_index = pending_parse_str.index_of(&delimiter);
+        let package_addr = pending_parse_str.substring(0, package_delimiter_index);
+        let package_id = address::from_ascii_bytes(package_addr.as_bytes());
+
+        let tail = pending_parse_str.substring(package_delimiter_index + 2, pending_parse_str.length());
+
+        let module_delimiter_index = tail.index_of(&delimiter);
+        let module_name = tail.substring(0, module_delimiter_index);
+
+        let struct_name_with_type = tail.substring(module_delimiter_index + 2, tail.length());
+
+        let delimiter = string(b"<");
+        let struct_name_delimiter_index = struct_name_with_type.index_of(&delimiter);
+        let struct_name = struct_name_with_type.substring(0, struct_name_delimiter_index);
+
+        (package_id, module_name, struct_name, struct_name_with_type)
+    }
+
+    public fun get_package_id<T>(): address {
+        let type_name = type_name::get<T>().get_address();
+        address::from_ascii_bytes(type_name.as_bytes())
+    }
+
+    public fun get_package_id_string<T>(): String {
+        type_name::get<T>().into_string()
+    }
+}