create-dubhe 0.1.13 → 1.2.0-pre.51

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/InitiaStdlib/stableswap.move

@@ -1,1659 +0,0 @@
-module initia_std::stableswap {
-    use std::event::Self;
-    use std::signer;
-    use std::error;
-    use std::vector;
-    use std::option::{Self, Option};
-
-    use initia_std::fungible_asset::{Self, FungibleAsset, Metadata};
-    use initia_std::block;
-    use initia_std::primary_fungible_store;
-    use initia_std::object::{Self, ExtendRef, Object};
-    use initia_std::bigdecimal::{Self, BigDecimal};
-    use initia_std::string::{Self, String};
-    use initia_std::coin;
-    use initia_std::table::{Self, Table};
-
-    const A_PRECISION: u256 = 100;
-
-    struct ModuleStore has key {
-        pools: Table<address, bool>,
-        pool_count: u64
-    }
-
-    struct Pool has key {
-        /// Extend Reference
-        extend_ref: ExtendRef,
-        /// ANN
-        ann: Ann,
-        /// swap fee
-        swap_fee_rate: BigDecimal,
-        /// Coin metadata
-        coin_metadata: vector<Object<Metadata>>,
-        /// Liqudiity token's burn capability
-        burn_cap: coin::BurnCapability,
-        /// Liqudiity token's freeze capability
-        freeze_cap: coin::FreezeCapability,
-        /// Liqudiity token's mint capability
-        mint_cap: coin::MintCapability
-    }
-
-    #[event]
-    struct CreatePoolEvent has drop, store {
-        coins: vector<address>,
-        liquidity_token: address,
-        ann: u64,
-        swap_fee_rate: BigDecimal
-    }
-
-    #[event]
-    struct ProvideEvent has drop, store {
-        coins: vector<address>,
-        coin_amounts: vector<u64>,
-        fee_amounts: vector<u64>,
-        liquidity_token: address,
-        liquidity: u64
-    }
-
-    #[event]
-    struct WithdrawEvent has drop, store {
-        coins: vector<address>,
-        coin_amounts: vector<u64>,
-        fee_amounts: vector<u64>,
-        liquidity_token: address,
-        liquidity: u64
-    }
-
-    #[event]
-    struct SwapEvent has drop, store {
-        offer_coin: address,
-        return_coin: address,
-        liquidity_token: address,
-        offer_amount: u64,
-        return_amount: u64,
-        fee_amount: u64
-    }
-
-    #[event]
-    struct UpdateSwapFeeEvent has drop, store {
-        liquidity_token: address,
-        swap_fee_rate: BigDecimal
-    }
-
-    #[event]
-    struct UpdateAnnEvent has drop, store {
-        liquidity_token: address,
-        ann: Ann
-    }
-
-    struct Ann has copy, drop, store {
-        ann_before: u64,
-        ann_after: u64,
-        timestamp_before: u64,
-        timestamp_after: u64
-    }
-
-    struct PoolResponse has copy, drop, store {
-        coin_metadata: vector<Object<Metadata>>,
-        coin_denoms: vector<String>,
-        coin_balances: vector<u64>,
-        current_ann: u64,
-        swap_fee_rate: BigDecimal
-    }
-
-    // Errors
-
-    /// Can not withdraw zero liquidity
-    const EZERO_LIQUIDITY: u64 = 2;
-
-    /// Return amount is smaller than the `min_return`
-    const EMIN_RETURN: u64 = 3;
-
-    /// Return liquidity amount is smaller than the `min_liquidity_amount`
-    const EMIN_LIQUIDITY: u64 = 4;
-
-    /// Returning coin amount of the result of the liquidity withdraw is smaller than min return
-    const EMIN_WITHDRAW: u64 = 5;
-
-    /// Base must be in the range of 0 < base < 2
-    const EOUT_OF_BASE_RANGE: u64 = 6;
-
-    /// Only chain can execute.
-    const EUNAUTHORIZED: u64 = 7;
-
-    /// Fee rate must be smaller than max fee rate
-    const EOUT_OF_SWAP_FEE_RATE_RANGE: u64 = 8;
-
-    /// end time must be larger than start time
-    const EWEIGHTS_TIMESTAMP: u64 = 9;
-
-    /// Wrong coin type given
-    const ECOIN_TYPE: u64 = 10;
-
-    /// Exceed max price impact
-    const EPRICE_IMPACT: u64 = 11;
-
-    /// LBP is not started, can not swap yet
-    const ELBP_NOT_STARTED: u64 = 14;
-
-    /// LBP is not ended, only swap allowed
-    const ELBP_NOT_ENDED: u64 = 15;
-
-    /// LBP start time must be larger than current time
-    const ELBP_START_TIME: u64 = 16;
-
-    /// All start_after must be provided or not
-    const ESTART_AFTER: u64 = 17;
-
-    const ESAME_COIN_TYPE: u64 = 19;
-
-    const EN_COINS: u64 = 20;
-
-    const EMAX_LIQUIDITY: u64 = 21;
-
-    // Constants
-    const MAX_LIMIT: u8 = 30;
-
-    #[view]
-    /// Return swap simulation result
-    public fun get_swap_simulation(
-        pool_obj: Object<Pool>,
-        offer_metadata: Object<Metadata>,
-        return_metadata: Object<Metadata>,
-        offer_amount: u64
-    ): u64 acquires Pool {
-        let (return_amount, fee_amount) =
-            swap_simulation(
-                pool_obj,
-                offer_metadata,
-                return_metadata,
-                offer_amount,
-                true
-            );
-
-        return_amount - fee_amount
-    }
-
-    #[view]
-    /// Return swap simulation result
-    public fun get_swap_simulation_given_out(
-        pool_obj: Object<Pool>,
-        offer_metadata: Object<Metadata>,
-        return_metadata: Object<Metadata>,
-        return_amount: u64
-    ): u64 acquires Pool {
-        let (offer_amount, _) =
-            swap_simulation(
-                pool_obj,
-                offer_metadata,
-                return_metadata,
-                return_amount,
-                false
-            );
-
-        offer_amount
-    }
-
-    #[view]
-    public fun get_swap_simulation_by_denom(
-        pool_obj: Object<Pool>,
-        offer_denom: String,
-        return_denom: String,
-        offer_amount: u64
-    ): u64 acquires Pool {
-        let offer_metadata = coin::denom_to_metadata(offer_denom);
-        let return_metadata = coin::denom_to_metadata(return_denom);
-        get_swap_simulation(
-            pool_obj,
-            offer_metadata,
-            return_metadata,
-            offer_amount
-        )
-    }
-
-    #[view]
-    public fun get_provide_simulation(
-        pool_obj: Object<Pool>, coin_amounts: vector<u64>
-    ): u64 acquires Pool {
-        let (liquidity_amount, _) = provide_simulation(pool_obj, coin_amounts);
-        liquidity_amount
-    }
-
-    #[view]
-    public fun get_imbalance_withdraw_simulation(
-        pool_obj: Object<Pool>, coin_amounts: vector<u64>
-    ): u64 acquires Pool {
-        let (liquidity_amount, _) =
-            imbalance_withdraw_simulation(pool_obj, coin_amounts, option::none());
-        liquidity_amount
-    }
-
-    #[view]
-    public fun get_single_asset_withdraw_simulation(
-        pool_obj: Object<Pool>,
-        return_coin_metadata: Object<Metadata>,
-        liquidity_amount: u64
-    ): u64 acquires Pool {
-        let pool = borrow_pool(pool_obj);
-
-        // get return index
-        let (found, return_index) = vector::index_of(
-            &pool.coin_metadata, &return_coin_metadata
-        );
-        assert!(found, error::invalid_argument(ECOIN_TYPE));
-
-        let (liquidity_amount, _) =
-            single_asset_withdraw_simulation(pool_obj, liquidity_amount, return_index);
-        liquidity_amount
-    }
-
-    #[view]
-    public fun get_pool(pool: Object<Pool>): PoolResponse acquires Pool {
-        let (coin_metadata, coin_balances, current_ann, swap_fee_rate) = pool_info(pool);
-        let coin_denoms = vector::map(
-            coin_metadata,
-            |metadata| coin::metadata_to_denom(metadata)
-        );
-
-        PoolResponse {
-            coin_metadata,
-            coin_denoms,
-            coin_balances,
-            current_ann,
-            swap_fee_rate
-        }
-    }
-
-    #[view]
-    // get all kinds of pool
-    // return vector of PoolResponse
-    public fun get_all_pools(
-        start_after: Option<address>, limit: u8
-    ): vector<PoolResponse> acquires ModuleStore, Pool {
-        if (limit > MAX_LIMIT) {
-            limit = MAX_LIMIT;
-        };
-
-        let module_store = borrow_global<ModuleStore>(@initia_std);
-
-        let res = vector[];
-        let pools_iter = table::iter(
-            &module_store.pools,
-            option::none(),
-            start_after,
-            2
-        );
-
-        while (vector::length(&res) < (limit as u64)
-            && table::prepare<address, bool>(pools_iter)) {
-            let (key, _) = table::next<address, bool>(pools_iter);
-            let pool_response = get_pool(object::address_to_object<Pool>(key));
-            vector::push_back(&mut res, pool_response)
-        };
-
-        res
-    }
-
-    #[view]
-    public fun spot_price(
-        pool_obj: Object<Pool>,
-        base_metadata: Object<Metadata>,
-        quote_metadata: Object<Metadata>
-    ): BigDecimal acquires Pool {
-        let pool = borrow_pool(pool_obj);
-        let ann = get_current_ann(&pool.ann);
-        let pool_addr = object::object_address(&pool_obj);
-        let amounts = get_pool_amounts(pool_addr, pool.coin_metadata);
-        let d = get_d(amounts, ann);
-        let swap_amount = d / 1000;
-
-        if (swap_amount < 1000000) {
-            let len = vector::length(&amounts);
-            let i = 0;
-            while (i < len) {
-                let amount = vector::borrow_mut(&mut amounts, i);
-                *amount = *amount * 1000000;
-                i = i + 1;
-            };
-
-            swap_amount = swap_amount * 1000000;
-        };
-
-        let (base_return_amount, _) =
-            swap_simulation_with_given_amounts(
-                pool_obj,
-                amounts,
-                quote_metadata,
-                base_metadata,
-                swap_amount,
-                true
-            );
-        let (quote_return_amount, _) =
-            swap_simulation_with_given_amounts(
-                pool_obj,
-                amounts,
-                base_metadata,
-                quote_metadata,
-                swap_amount,
-                true
-            );
-
-        bigdecimal::from_ratio_u64(
-            quote_return_amount + swap_amount,
-            base_return_amount + swap_amount
-        )
-    }
-
-    fun init_module(chain: &signer) {
-        move_to(
-            chain,
-            ModuleStore { pools: table::new(), pool_count: 0 }
-        )
-    }
-
-    public fun unpack_pool_response(
-        pool_response: &PoolResponse
-    ): (vector<Object<Metadata>>, vector<String>, vector<u64>, u64, BigDecimal) {
-        (
-            pool_response.coin_metadata,
-            pool_response.coin_denoms,
-            pool_response.coin_balances,
-            pool_response.current_ann,
-            pool_response.swap_fee_rate
-        )
-    }
-
-    public entry fun create_pool_script(
-        creator: &signer,
-        name: String,
-        symbol: String,
-        swap_fee_rate: BigDecimal,
-        coin_metadata: vector<Object<Metadata>>,
-        coin_amounts: vector<u64>,
-        ann: u64
-    ) acquires Pool, ModuleStore {
-        let coins: vector<FungibleAsset> = vector[];
-        let i = 0;
-        let n = vector::length(&coin_metadata);
-        while (i < n) {
-            let metadata = *vector::borrow(&coin_metadata, i);
-            let amount = *vector::borrow(&coin_amounts, i);
-            vector::push_back(
-                &mut coins,
-                primary_fungible_store::withdraw(creator, metadata, amount)
-            );
-            i = i + 1;
-        };
-
-        let liquidity_token = create_pool(
-            creator, name, symbol, swap_fee_rate, coins, ann
-        );
-        primary_fungible_store::deposit(signer::address_of(creator), liquidity_token);
-    }
-
-    public entry fun update_swap_fee_rate(
-        account: &signer, pool_obj: Object<Pool>, new_swap_fee_rate: BigDecimal
-    ) acquires Pool {
-        check_chain_permission(account);
-        let pool = borrow_pool_mut(pool_obj);
-        pool.swap_fee_rate = new_swap_fee_rate;
-
-        event::emit(
-            UpdateSwapFeeEvent {
-                liquidity_token: object::object_address(&pool_obj),
-                swap_fee_rate: new_swap_fee_rate
-            }
-        )
-    }
-
-    public entry fun update_ann(
-        account: &signer,
-        pool_obj: Object<Pool>,
-        ann_after: u64,
-        timestamp_after: u64
-    ) acquires Pool {
-        check_chain_permission(account);
-        let (_, timestamp) = block::get_block_info();
-        let pool = borrow_pool_mut(pool_obj);
-        pool.ann.ann_before = get_current_ann(&pool.ann);
-        pool.ann.timestamp_before = timestamp;
-        pool.ann.ann_after = ann_after;
-        pool.ann.timestamp_after = timestamp_after;
-
-        event::emit(
-            UpdateAnnEvent {
-                liquidity_token: object::object_address(&pool_obj),
-                ann: pool.ann
-            }
-        )
-    }
-
-    public entry fun provide_liquidity_script(
-        account: &signer,
-        pool_obj: Object<Pool>,
-        coin_amounts: vector<u64>,
-        min_liquidity: Option<u64>
-    ) acquires Pool {
-        let coins: vector<FungibleAsset> = vector[];
-        let pool = borrow_pool(pool_obj);
-
-        let i = 0;
-        let n = vector::length(&coin_amounts);
-        while (i < n) {
-            let metadata = *vector::borrow(&pool.coin_metadata, i);
-            let amount = *vector::borrow(&coin_amounts, i);
-            vector::push_back(
-                &mut coins,
-                primary_fungible_store::withdraw(account, metadata, amount)
-            );
-            i = i + 1;
-        };
-
-        let liquidity_token = provide_liquidity(pool_obj, coins, min_liquidity);
-        primary_fungible_store::deposit(signer::address_of(account), liquidity_token);
-    }
-
-    public entry fun withdraw_liquidity_script(
-        account: &signer,
-        pool_obj: Object<Pool>,
-        liquidity_amount: u64,
-        min_return_amounts: vector<Option<u64>>
-    ) acquires Pool {
-        let liquidity_token =
-            primary_fungible_store::withdraw(account, pool_obj, liquidity_amount);
-        let coins = withdraw_liquidity(liquidity_token, min_return_amounts);
-
-        let i = 0;
-        let n = vector::length(&coins);
-        while (i < n) {
-            let coin = vector::pop_back(&mut coins);
-            primary_fungible_store::deposit(signer::address_of(account), coin);
-            i = i + 1;
-        };
-
-        vector::destroy_empty(coins);
-    }
-
-    public entry fun imbalance_withdraw_liquidity_script(
-        account: &signer,
-        pool_obj: Object<Pool>,
-        coin_amounts: vector<u64>,
-        max_liquidity: Option<u64>
-    ) acquires Pool {
-        let (liquidity_amount, fee_amounts) =
-            imbalance_withdraw_simulation(pool_obj, coin_amounts, max_liquidity);
-        let liquidity_token =
-            primary_fungible_store::withdraw(account, pool_obj, liquidity_amount);
-        let pool = borrow_pool(pool_obj);
-        let pool_signer = object::generate_signer_for_extending(&pool.extend_ref);
-        coin::burn(&pool.burn_cap, liquidity_token);
-
-        let n = vector::length(&pool.coin_metadata);
-
-        let i = 0;
-        while (i < n) {
-            let coin_metadata = *vector::borrow(&pool.coin_metadata, i);
-            let amount = *vector::borrow(&mut coin_amounts, i);
-            let coin =
-                primary_fungible_store::withdraw(&pool_signer, coin_metadata, amount);
-            primary_fungible_store::deposit(signer::address_of(account), coin);
-            i = i + 1;
-        };
-
-        event::emit<WithdrawEvent>(
-            WithdrawEvent {
-                coins: get_coin_addresses(pool.coin_metadata),
-                coin_amounts,
-                fee_amounts,
-                liquidity_token: object::object_address(&pool_obj),
-                liquidity: liquidity_amount
-            }
-        );
-    }
-
-    public entry fun single_asset_withdraw_liquidity_script(
-        account: &signer,
-        pool_obj: Object<Pool>,
-        return_coin_metadata: Object<Metadata>,
-        liquidity_amount: u64,
-        min_return_amount: Option<u64>
-    ) acquires Pool {
-        let liquidity_token =
-            primary_fungible_store::withdraw(account, pool_obj, liquidity_amount);
-        let return_coin =
-            single_asset_withdraw_liquidity(
-                liquidity_token,
-                return_coin_metadata,
-                min_return_amount
-            );
-        primary_fungible_store::deposit(signer::address_of(account), return_coin);
-    }
-
-    public entry fun swap_script(
-        account: &signer,
-        pool_obj: Object<Pool>,
-        offer_coin_metadata: Object<Metadata>,
-        return_coin_metadata: Object<Metadata>,
-        offer_amount: u64,
-        min_return_amount: Option<u64>
-    ) acquires Pool {
-        let offer_coin =
-            primary_fungible_store::withdraw(account, offer_coin_metadata, offer_amount);
-        let return_coin =
-            swap(
-                pool_obj,
-                offer_coin,
-                return_coin_metadata,
-                min_return_amount
-            );
-        primary_fungible_store::deposit(signer::address_of(account), return_coin);
-    }
-
-    fun max_fee_rate(): BigDecimal {
-        bigdecimal::from_ratio_u64(1, 100)
-    }
-
-    public fun create_pool(
-        creator: &signer,
-        name: String,
-        symbol: String,
-        swap_fee_rate: BigDecimal,
-        coins: vector<FungibleAsset>,
-        ann: u64
-    ): FungibleAsset acquires Pool, ModuleStore {
-        assert!(
-            vector::length(&coins) >= 2,
-            error::invalid_argument(EN_COINS)
-        );
-        let (_, timestamp) = block::get_block_info();
-        let (mint_cap, burn_cap, freeze_cap, extend_ref) =
-            coin::initialize_and_generate_extend_ref(
-                creator,
-                option::none(),
-                name,
-                symbol,
-                6,
-                string::utf8(b""),
-                string::utf8(b"")
-            );
-
-        let coin_metadata: vector<Object<Metadata>> = vector[];
-        let len = vector::length(&coins);
-        let i = 0;
-        while (i < len) {
-            let j = i + 1;
-            let coin_metadata_i =
-                fungible_asset::metadata_from_asset(vector::borrow(&coins, i));
-            while (j < len) {
-                let coin_metadata_j =
-                    fungible_asset::metadata_from_asset(vector::borrow(&coins, j));
-                assert!(
-                    coin_metadata_i != coin_metadata_j,
-                    error::invalid_argument(ESAME_COIN_TYPE)
-                );
-                j = j + 1;
-            };
-            vector::push_back(&mut coin_metadata, coin_metadata_i);
-            i = i + 1;
-        };
-
-        assert!(
-            bigdecimal::le(swap_fee_rate, max_fee_rate()),
-            error::invalid_argument(EOUT_OF_SWAP_FEE_RATE_RANGE)
-        );
-
-        let pool_signer = &object::generate_signer_for_extending(&extend_ref);
-        let pool_address = signer::address_of(pool_signer);
-        // transfer pool object's ownership to initia_std
-        object::transfer_raw(creator, pool_address, @initia_std);
-
-        move_to(
-            pool_signer,
-            Pool {
-                extend_ref,
-                ann: Ann {
-                    ann_before: ann,
-                    ann_after: ann,
-                    timestamp_before: timestamp,
-                    timestamp_after: timestamp
-                },
-                swap_fee_rate,
-                coin_metadata,
-                burn_cap,
-                freeze_cap,
-                mint_cap
-            }
-        );
-
-        let liquidity_token =
-            provide_liquidity(
-                object::address_to_object<Pool>(pool_address),
-                coins,
-                option::none()
-            );
-
-        // update module store
-        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
-        module_store.pool_count = module_store.pool_count + 1;
-
-        table::add(&mut module_store.pools, pool_address, true);
-
-        // emit create pool event
-        event::emit<CreatePoolEvent>(
-            CreatePoolEvent {
-                coins: get_coin_addresses(coin_metadata),
-                liquidity_token: pool_address,
-                ann,
-                swap_fee_rate
-            }
-        );
-
-        return liquidity_token
-    }
-
-    public fun provide_liquidity(
-        pool_obj: Object<Pool>, coins: vector<FungibleAsset>, min_liquidity: Option<u64>
-    ): FungibleAsset acquires Pool {
-        let pool = borrow_pool(pool_obj);
-        // check before simaultion
-        let n = check_coin_metadata(&pool.coin_metadata, &coins);
-        let amounts = get_amounts(&coins);
-        let (liquidity_amount, fee_amounts) = provide_simulation(pool_obj, amounts);
-
-        assert!(
-            option::is_none(&min_liquidity)
-                || *option::borrow(&min_liquidity) <= liquidity_amount,
-            error::invalid_state(EMIN_LIQUIDITY)
-        );
-
-        let pool_addr = object::object_address(&pool_obj);
-        let i = 0;
-        while (i < n) {
-            let fa = vector::pop_back(&mut coins);
-            primary_fungible_store::deposit(pool_addr, fa);
-            i = i + 1;
-        };
-        vector::destroy_empty(coins);
-
-        let pool = borrow_pool(pool_obj);
-        let liquidity_token = coin::mint(&pool.mint_cap, liquidity_amount);
-
-        event::emit<ProvideEvent>(
-            ProvideEvent {
-                coins: get_coin_addresses(pool.coin_metadata),
-                coin_amounts: amounts,
-                fee_amounts,
-                liquidity_token: pool_addr,
-                liquidity: liquidity_amount
-            }
-        );
-
-        return liquidity_token
-    }
-
-    public fun withdraw_liquidity(
-        liquidity_token: FungibleAsset, min_return_amounts: vector<Option<u64>>
-    ): vector<FungibleAsset> acquires Pool {
-        let pool_addr =
-            object::object_address(
-                &fungible_asset::metadata_from_asset(&liquidity_token)
-            );
-        let pool_obj = object::address_to_object<Pool>(pool_addr);
-        let liquidity_amount = fungible_asset::amount(&liquidity_token);
-        assert!(
-            liquidity_amount != 0,
-            error::invalid_argument(EZERO_LIQUIDITY)
-        );
-        let pool = borrow_pool(pool_obj);
-        let pool_signer = object::generate_signer_for_extending(&pool.extend_ref);
-        let total_supply = option::extract(&mut fungible_asset::supply(pool_obj));
-        let n = vector::length(&pool.coin_metadata);
-
-        let return_coins: vector<FungibleAsset> = vector[];
-        let pool_amounts = get_pool_amounts(pool_addr, pool.coin_metadata);
-        let coin_amounts: vector<u64> = vector[];
-
-        let fee_amounts: vector<u64> = vector[];
-        let i = 0;
-        while (i < n) {
-            vector::push_back(&mut fee_amounts, 0);
-            let pool_amount = *vector::borrow(&pool_amounts, i);
-            let return_amount =
-                (
-                    mul_div_u128(
-                        (pool_amount as u128),
-                        (liquidity_amount as u128),
-                        total_supply
-                    ) as u64
-                );
-            let min_return = vector::borrow(&min_return_amounts, i);
-            let coin_metadata = *vector::borrow(&pool.coin_metadata, i);
-
-            assert!(
-                option::is_none(min_return)
-                    || *option::borrow(min_return) <= return_amount,
-                error::invalid_state(EMIN_WITHDRAW)
-            );
-
-            vector::push_back(&mut coin_amounts, return_amount);
-            vector::push_back(
-                &mut return_coins,
-                primary_fungible_store::withdraw(
-                    &pool_signer, coin_metadata, return_amount
-                )
-            );
-            i = i + 1;
-        };
-
-        coin::burn(&pool.burn_cap, liquidity_token);
-
-        event::emit<WithdrawEvent>(
-            WithdrawEvent {
-                coins: get_coin_addresses(pool.coin_metadata),
-                coin_amounts,
-                fee_amounts,
-                liquidity_token: pool_addr,
-                liquidity: liquidity_amount
-            }
-        );
-
-        return return_coins
-    }
-
-    public fun single_asset_withdraw_liquidity(
-        liquidity_token: FungibleAsset,
-        return_coin_metadata: Object<Metadata>,
-        min_return_amount: Option<u64>
-    ): FungibleAsset acquires Pool {
-        // get pool infos
-        let pool_addr =
-            object::object_address(
-                &fungible_asset::metadata_from_asset(&liquidity_token)
-            );
-        let pool_obj = object::address_to_object<Pool>(pool_addr);
-        let liquidity_amount = fungible_asset::amount(&liquidity_token);
-        assert!(
-            liquidity_amount != 0,
-            error::invalid_argument(EZERO_LIQUIDITY)
-        );
-
-        let pool = borrow_pool(pool_obj);
-        let pool_signer = object::generate_signer_for_extending(&pool.extend_ref);
-        let n = vector::length(&pool.coin_metadata);
-
-        // get return index
-        let (found, return_index) = vector::index_of(
-            &pool.coin_metadata, &return_coin_metadata
-        );
-        assert!(found, error::invalid_argument(ECOIN_TYPE));
-
-        // calculate amount of returning asset
-        let (return_amount, fee) =
-            single_asset_withdraw_simulation(pool_obj, liquidity_amount, return_index);
-        assert!(
-            option::is_none(&min_return_amount)
-                || *option::borrow(&min_return_amount) <= return_amount,
-            error::invalid_state(EMIN_RETURN)
-        );
-
-        // withdraw return coin
-        let return_coin =
-            primary_fungible_store::withdraw(
-                &pool_signer,
-                return_coin_metadata,
-                return_amount
-            );
-
-        // burn liquidity token
-        let pool = borrow_pool(pool_obj);
-        coin::burn(&pool.burn_cap, liquidity_token);
-
-        // generate withdraw/fee amounts for event
-        let coin_amounts: vector<u64> = vector[];
-        let fee_amounts: vector<u64> = vector[];
-        let i = 0;
-        while (i < n) {
-            let (amount, fee) = if (i == return_index) {
-                (return_amount, fee)
-            } else { (0, 0) };
-            vector::push_back(&mut coin_amounts, amount);
-            vector::push_back(&mut fee_amounts, fee);
-            i = i + 1;
-        };
-
-        // emit withdraw event
-        event::emit<WithdrawEvent>(
-            WithdrawEvent {
-                coins: get_coin_addresses(pool.coin_metadata),
-                coin_amounts,
-                fee_amounts,
-                liquidity_token: pool_addr,
-                liquidity: liquidity_amount
-            }
-        );
-
-        return_coin
-    }
-
-    public fun swap(
-        pool_obj: Object<Pool>,
-        offer_coin: FungibleAsset,
-        return_coin_metadata: Object<Metadata>,
-        min_return_amount: Option<u64>
-    ): FungibleAsset acquires Pool {
-        let offer_coin_metadata = fungible_asset::metadata_from_asset(&offer_coin);
-        let offer_amount = fungible_asset::amount(&offer_coin);
-        let (return_amount, fee_amount) =
-            swap_simulation(
-                pool_obj,
-                offer_coin_metadata,
-                return_coin_metadata,
-                offer_amount,
-                true
-            );
-        return_amount = return_amount - fee_amount;
-
-        assert!(
-            option::is_none(&min_return_amount)
-                || *option::borrow(&min_return_amount) <= return_amount,
-            error::invalid_state(EMIN_RETURN)
-        );
-
-        let pool = borrow_pool(pool_obj);
-        let pool_addr = object::object_address(&pool_obj);
-        let pool_signer = object::generate_signer_for_extending(&pool.extend_ref);
-        primary_fungible_store::deposit(pool_addr, offer_coin);
-        let return_coin =
-            primary_fungible_store::withdraw(
-                &pool_signer,
-                return_coin_metadata,
-                return_amount
-            );
-
-        event::emit<SwapEvent>(
-            SwapEvent {
-                offer_coin: object::object_address(&offer_coin_metadata),
-                return_coin: object::object_address(&return_coin_metadata),
-                liquidity_token: pool_addr,
-                fee_amount,
-                offer_amount,
-                return_amount
-            }
-        );
-
-        return return_coin
-    }
-
-    public fun pool_info(
-        pool_obj: Object<Pool>
-    ): (vector<Object<Metadata>>, vector<u64>, u64, BigDecimal) acquires Pool {
-        let pool_addr = object::object_address(&pool_obj);
-        let pool = borrow_global<Pool>(pool_addr);
-
-        let ann = get_current_ann(&pool.ann);
-        let pool_amounts = get_pool_amounts(pool_addr, pool.coin_metadata);
-
-        (pool.coin_metadata, pool_amounts, ann, pool.swap_fee_rate)
-    }
-
-    inline fun borrow_pool(pool_obj: Object<Pool>): &Pool {
-        borrow_global<Pool>(object::object_address(&pool_obj))
-    }
-
-    inline fun borrow_pool_mut(pool_obj: Object<Pool>): &mut Pool {
-        borrow_global_mut<Pool>(object::object_address(&pool_obj))
-    }
-
-    fun get_current_ann(ann: &Ann): u64 {
-        let (_, timestamp) = block::get_block_info();
-
-        if (timestamp >= ann.timestamp_after) {
-            return ann.ann_after
-        };
-
-        if (ann.ann_after > ann.ann_before) {
-            return ann.ann_before
-                + (ann.ann_after - ann.ann_before) * (timestamp - ann.timestamp_before)
-                    / (ann.timestamp_after - ann.timestamp_before)
-        } else {
-            return ann.ann_before
-                - (ann.ann_before - ann.ann_after) * (timestamp - ann.timestamp_before)
-                    / (ann.timestamp_after - ann.timestamp_before)
-        }
-    }
-
-    fun check_coin_metadata(
-        coin_metadata: &vector<Object<Metadata>>, coins: &vector<FungibleAsset>
-    ): u64 {
-        let len = vector::length(coin_metadata);
-        assert!(
-            len == vector::length(coins),
-            error::invalid_argument(EN_COINS)
-        );
-
-        let i = 0;
-        while (i < len) {
-            let metadata = vector::borrow(coin_metadata, i);
-            let metadata_ = fungible_asset::metadata_from_asset(
-                vector::borrow(coins, i)
-            );
-            assert!(
-                *metadata == metadata_,
-                error::invalid_argument(ECOIN_TYPE)
-            );
-            i = i + 1;
-        };
-
-        return len
-    }
-
-    fun get_pool_amounts(
-        pool_addr: address, coin_metadata: vector<Object<Metadata>>
-    ): vector<u64> {
-        let amounts: vector<u64> = vector[];
-        let len = vector::length(&coin_metadata);
-        let i = 0;
-        while (i < len) {
-            let metadata = *vector::borrow(&coin_metadata, i);
-            vector::push_back(
-                &mut amounts,
-                primary_fungible_store::balance(pool_addr, metadata)
-            );
-            i = i + 1;
-        };
-
-        return amounts
-    }
-
-    fun get_amounts(coins: &vector<FungibleAsset>): vector<u64> {
-        let amounts: vector<u64> = vector[];
-        let len = vector::length(coins);
-        let i = 0;
-        while (i < len) {
-            let amount = fungible_asset::amount(vector::borrow(coins, i));
-            vector::push_back(&mut amounts, amount);
-            i = i + 1;
-        };
-
-        return amounts
-    }
-
-    fun get_coin_addresses(coin_metadata: vector<Object<Metadata>>): vector<address> {
-        let addresses: vector<address> = vector[];
-        let len = vector::length(&coin_metadata);
-        let i = 0;
-        while (i < len) {
-            let addr = object::object_address(&*vector::borrow(&coin_metadata, i));
-            vector::push_back(&mut addresses, addr);
-            i = i + 1;
-        };
-
-        return addresses
-    }
-
-    fun get_d(amounts: vector<u64>, ann: u64): u64 {
-        let ann = (ann as u256);
-
-        let sum: u256 = 0;
-        let n = (vector::length(&amounts) as u256);
-        let i = 0;
-        while (i < (n as u64)) {
-            sum = sum + (*vector::borrow(&amounts, i) as u256);
-            i = i + 1;
-        };
-        if (sum == 0) return 0;
-        let d = sum;
-
-        let i = 0;
-
-        // converge
-        // d = (ann * sum - d_prod) / (ann - 1)
-        while (i < 255) {
-            let d_prev = d;
-            // D ** (n + 1) / (n ** n * prod)
-            let d_prod = d;
-            let j = 0;
-            while (j < (n as u64)) {
-                d_prod = d_prod * d / (n as u256)
-                    / (*vector::borrow(&amounts, j) as u256);
-                j = j + 1;
-            };
-
-            d = (ann * sum / A_PRECISION + d_prod * n) * d
-                / ((ann - A_PRECISION) * d / A_PRECISION + (n + 1) * d_prod);
-            if (d > d_prev) {
-                if (d - d_prev <= 1) break
-            } else {
-                if (d_prev - d <= 1) break
-            };
-            i = i + 1;
-        };
-
-        return (d as u64)
-    }
-
-    /// get counterparty's amount
-    fun get_y(
-        offer_index: u64,
-        return_index: u64,
-        amount: u64,
-        pool_amounts: vector<u64>,
-        ann: u64,
-        is_offer_amount: bool
-    ): u64 {
-        let d = get_d(pool_amounts, ann);
-
-        let y_index =
-            if (is_offer_amount) {
-                let pool_amount = vector::borrow_mut(&mut pool_amounts, offer_index);
-                *pool_amount = *pool_amount + amount;
-                return_index
-            } else {
-                let pool_amount = vector::borrow_mut(&mut pool_amounts, return_index);
-                *pool_amount = *pool_amount - amount;
-                offer_index
-            };
-
-        get_y_with_given_d(pool_amounts, y_index, ann, d)
-    }
-
-    fun get_y_with_given_d(
-        pool_amounts: vector<u64>,
-        y_index: u64,
-        ann: u64,
-        d: u64
-    ): u64 {
-        let d = (d as u256);
-        let ann = (ann as u256);
-        // Done by solving quadratic equation iteratively.
-        // x_1**2 + x_1 * (sum' - (A*n**n - 1) * D / (A * n**n)) = D ** (n + 1) / (n ** (2 * n) * prod' * A)
-        // y**2 + b*y = c
-
-        // y = (y**2 + c) / (2*y + b)
-        let n = vector::length(&pool_amounts);
-        let i = 0;
-        let sum = 0; // sum'
-        let c = d;
-        while (i < n) {
-            if (i == y_index) {
-                i = i + 1;
-                continue
-            };
-
-            let pool_amount = (*vector::borrow(&pool_amounts, i) as u256);
-
-            sum = sum + pool_amount;
-            c = c * d / (pool_amount * (n as u256));
-            i = i + 1;
-        };
-
-        c = c * d * A_PRECISION / ann / (n as u256);
-        let b_plus_d = sum + d * A_PRECISION / ann; // need to sub d but sub later due to value must be less than 0
-
-        let y_prev;
-        let y = d;
-
-        let i = 0;
-        // converge
-        while (i < 255) {
-            y_prev = y;
-            y = (y * y + c) / (2 * y + b_plus_d - d); // sub d here
-
-            if (y > y_prev) {
-                if (y - y_prev <= 1) break
-            } else {
-                if (y_prev - y <= 1) break
-            };
-            i = i + 1;
-        };
-
-        (y as u64)
-    }
-
-    public fun single_asset_withdraw_simulation(
-        pool_obj: Object<Pool>, liquidity_amount: u64, return_index: u64
-    ): (u64, u64) acquires Pool {
-        let pool_addr = object::object_address(&pool_obj);
-        let pool = borrow_global<Pool>(pool_addr);
-        let n = vector::length(&pool.coin_metadata);
-        let ann = get_current_ann(&pool.ann);
-        let withdraw_fee_rate =
-            bigdecimal::div_by_u64(
-                bigdecimal::mul_by_u64(pool.swap_fee_rate, n),
-                4 * (n - 1)
-            );
-        let total_supply = option::extract(&mut fungible_asset::supply(pool_obj));
-        let pool_amounts = get_pool_amounts(pool_addr, pool.coin_metadata);
-        let d_before = get_d(pool_amounts, ann);
-        let d_after =
-            d_before
-                - (
-                    mul_div_u128(
-                        (liquidity_amount as u128),
-                        (d_before as u128),
-                        total_supply
-                    ) as u64
-                );
-
-        let y_without_fee = get_y_with_given_d(pool_amounts, return_index, ann, d_after);
-        let return_amount_without_fee =
-            *vector::borrow(&pool_amounts, return_index) - y_without_fee;
-
-        // calculate fee
-
-        // amount that after fee removed
-        let pool_amounts_reduced = pool_amounts;
-        let i = 0;
-        while (i < n) {
-            // get difference with ideal amount
-            let amount_diff =
-                if (i == return_index) {
-                    mul_div_u64(
-                        *vector::borrow(&pool_amounts, i),
-                        d_after,
-                        d_before
-                    ) - y_without_fee
-                } else {
-                    *vector::borrow(&pool_amounts, i)
-                        - mul_div_u64(
-                            *vector::borrow(&pool_amounts, i),
-                            d_after,
-                            d_before
-                        )
-                };
-
-            let pool_amount = vector::borrow_mut(&mut pool_amounts_reduced, i);
-            *pool_amount = *pool_amount
-                - bigdecimal::mul_by_u64_truncate(withdraw_fee_rate, amount_diff);
-            i = i + 1;
-        };
-
-        let return_amount =
-            *vector::borrow(&pool_amounts_reduced, return_index)
-                - get_y_with_given_d(
-                    pool_amounts_reduced,
-                    return_index,
-                    ann,
-                    d_after
-                ) - 1; // sub 1 in case of rounding errors
-
-        (return_amount, return_amount_without_fee - return_amount)
-    }
-
-    public fun imbalance_withdraw_simulation(
-        pool_obj: Object<Pool>,
-        coin_amounts: vector<u64>,
-        max_liquidity_amount: Option<u64>
-    ): (u64, vector<u64>) acquires Pool {
-        let pool_addr = object::object_address(&pool_obj);
-        let pool = borrow_global<Pool>(pool_addr);
-        let n = vector::length(&pool.coin_metadata);
-        let ann = get_current_ann(&pool.ann);
-        let withdraw_fee_rate =
-            bigdecimal::div_by_u64(
-                bigdecimal::mul_by_u64(pool.swap_fee_rate, n),
-                4 * (n - 1)
-            );
-        let total_supply = option::extract(&mut fungible_asset::supply(pool_obj));
-
-        assert!(
-            n == vector::length(&coin_amounts),
-            error::invalid_argument(EN_COINS)
-        );
-
-        let pool_amounts_before = get_pool_amounts(pool_addr, pool.coin_metadata);
-        let pool_amounts_after = copy pool_amounts_before;
-        let d_before = get_d(pool_amounts_before, ann);
-
-        // update pool amounts after withdraw
-        let i = 0;
-        while (i < n) {
-            let pool_amount = vector::borrow_mut(&mut pool_amounts_after, i);
-            let withdraw_amount = *vector::borrow(&coin_amounts, i);
-            *pool_amount = *pool_amount - withdraw_amount;
-            i = i + 1;
-        };
-
-        let d_after_without_fee = get_d(pool_amounts_after, ann);
-
-        let fees: vector<u64> = vector[];
-
-        // calculate fee
-        let i = 0;
-        while (i < n) {
-            let ideal_balance =
-                mul_div_u64(
-                    *vector::borrow(&pool_amounts_before, i),
-                    d_after_without_fee,
-                    d_before
-                );
-            let balance_after = vector::borrow_mut(&mut pool_amounts_after, i);
-            let amount_diff =
-                if (*balance_after > ideal_balance) {
-                    *balance_after - ideal_balance
-                } else {
-                    ideal_balance - *balance_after
-                };
-            let fee = bigdecimal::mul_by_u64_ceil(withdraw_fee_rate, amount_diff);
-            vector::push_back(&mut fees, fee);
-            *balance_after = *balance_after - fee; // to get d_after remove fee
-            i = i + 1;
-        };
-
-        let d_after = get_d(pool_amounts_after, ann);
-        let liquidity_amount =
-            (
-                mul_div_u128(
-                    total_supply,
-                    (d_before - d_after as u128),
-                    (d_before as u128)
-                ) as u64
-            );
-        assert!(
-            liquidity_amount != 0,
-            error::invalid_state(EZERO_LIQUIDITY)
-        );
-        liquidity_amount = liquidity_amount + 1; // add 1 just in case of rounding errors
-
-        assert!(
-            option::is_none(&max_liquidity_amount)
-                || *option::borrow(&max_liquidity_amount) >= liquidity_amount,
-            error::invalid_state(EMAX_LIQUIDITY)
-        );
-
-        (liquidity_amount, fees)
-    }
-
-    public fun swap_simulation(
-        pool_obj: Object<Pool>,
-        offer_coin_metadata: Object<Metadata>,
-        return_coin_metadata: Object<Metadata>,
-        amount: u64,
-        is_offer_amount: bool
-    ): (u64, u64) acquires Pool {
-        let pool = borrow_pool(pool_obj);
-        let pool_addr = object::object_address(&pool_obj);
-        let pool_amounts = get_pool_amounts(pool_addr, pool.coin_metadata);
-        swap_simulation_with_given_amounts(
-            pool_obj,
-            pool_amounts,
-            offer_coin_metadata,
-            return_coin_metadata,
-            amount,
-            is_offer_amount
-        )
-    }
-
-    public fun provide_simulation(
-        pool_obj: Object<Pool>, amounts: vector<u64>
-    ): (u64, vector<u64>) acquires Pool {
-        let pool = borrow_pool(pool_obj);
-        let pool_addr = object::object_address(&pool_obj);
-        let ann = get_current_ann(&pool.ann);
-
-        let pool_amounts_before = get_pool_amounts(pool_addr, pool.coin_metadata);
-        let d_before = get_d(pool_amounts_before, ann);
-        let total_supply = option::extract(&mut fungible_asset::supply(pool_obj));
-        let n = vector::length(&amounts);
-
-        // pool amounts before adjust fee
-        let pool_amounts_after: vector<u64> = vector[];
-        let i = 0;
-        while (i < n) {
-            let pool_amount = *vector::borrow(&pool_amounts_before, i);
-            let offer_amount = *vector::borrow(&amounts, i);
-            if (total_supply == 0) {
-                assert!(
-                    offer_amount > 0,
-                    error::invalid_argument(EZERO_LIQUIDITY)
-                );
-            };
-            vector::push_back(
-                &mut pool_amounts_after,
-                pool_amount + offer_amount
-            );
-            i = i + 1;
-        };
-
-        let d_ideal = get_d(pool_amounts_after, ann);
-        let fee_amounts: vector<u64> = vector[];
-
-        // calc fees
-        let liquidity_amount =
-            if (total_supply > 0) {
-                let provide_fee_rate =
-                    bigdecimal::div_by_u64(
-                        bigdecimal::mul_by_u64(pool.swap_fee_rate, n),
-                        4 * (n - 1)
-                    );
-                i = 0;
-                while (i < n) {
-                    let pool_amount_before = *vector::borrow(&pool_amounts_before, i);
-                    let pool_amount_after = vector::borrow_mut(
-                        &mut pool_amounts_after, i
-                    );
-                    let ideal_balance = mul_div_u64(
-                        d_ideal, pool_amount_before, d_before
-                    );
-                    let diff =
-                        if (ideal_balance > *pool_amount_after) {
-                            ideal_balance - *pool_amount_after
-                        } else {
-                            *pool_amount_after - ideal_balance
-                        };
-                    let fee = bigdecimal::mul_by_u64_ceil(provide_fee_rate, diff);
-                    vector::push_back(&mut fee_amounts, fee);
-                    *pool_amount_after = *pool_amount_after - fee;
-                    i = i + 1;
-                };
-
-                let d_real = get_d(pool_amounts_after, ann);
-                (
-                    mul_div_u128(
-                        total_supply,
-                        (d_real - d_before as u128),
-                        (d_before as u128)
-                    ) as u64
-                )
-            } else {
-                d_ideal
-            };
-
-        (liquidity_amount, fee_amounts)
-    }
-
-    fun swap_simulation_with_given_amounts(
-        pool_obj: Object<Pool>,
-        pool_amounts: vector<u64>,
-        offer_coin_metadata: Object<Metadata>,
-        return_coin_metadata: Object<Metadata>,
-        amount: u64,
-        is_offer_amount: bool
-    ): (u64, u64) acquires Pool {
-        assert!(
-            offer_coin_metadata != return_coin_metadata,
-            error::invalid_argument(ESAME_COIN_TYPE)
-        );
-        let pool = borrow_pool(pool_obj);
-        let n = vector::length(&pool.coin_metadata);
-
-        let ann = get_current_ann(&pool.ann);
-        let offer_index = n;
-        let return_index = n;
-        let i = 0;
-        while (i < n) {
-            let metadata = *vector::borrow(&pool.coin_metadata, i);
-            if (metadata == offer_coin_metadata) {
-                offer_index = i
-            };
-            if (metadata == return_coin_metadata) {
-                return_index = i
-            };
-            if (offer_index != n && return_index != n) { break };
-            i = i + 1;
-        };
-
-        assert!(
-            offer_index != n && return_index != n,
-            error::invalid_argument(ECOIN_TYPE)
-        );
-
-        if (!is_offer_amount) {
-            amount = amount + 1; // for revert sub 1 when get return amount
-
-            // adjust fee. amount = amount * 1 / (1 - f)
-            let return_amount =
-                bigdecimal::truncate_u64(
-                    bigdecimal::div(
-                        bigdecimal::from_u64(amount),
-                        bigdecimal::sub(bigdecimal::one(), pool.swap_fee_rate)
-                    )
-                );
-            let fee_amount = return_amount - amount;
-
-            let y =
-                get_y(
-                    offer_index,
-                    return_index,
-                    return_amount,
-                    pool_amounts,
-                    ann,
-                    is_offer_amount
-                );
-            let offer_amount = y - *vector::borrow(&pool_amounts, offer_index);
-
-            (offer_amount, fee_amount)
-        } else {
-            let y =
-                get_y(
-                    offer_index,
-                    return_index,
-                    amount,
-                    pool_amounts,
-                    ann,
-                    is_offer_amount
-                );
-
-            let return_amount = *vector::borrow(&pool_amounts, return_index) - y - 1; // sub 1 in case of rounding errors
-            let fee_amount =
-                bigdecimal::mul_by_u64_ceil(pool.swap_fee_rate, return_amount);
-
-            (return_amount, fee_amount)
-        }
-    }
-
-    fun mul_div_u64(a: u64, b: u64, c: u64): u64 {
-        return ((a as u128) * (b as u128) / (c as u128) as u64)
-    }
-
-    fun mul_div_u128(a: u128, b: u128, c: u128): u128 {
-        return ((a as u256) * (b as u256) / (c as u256) as u128)
-    }
-
-    /// Check signer is chain
-    fun check_chain_permission(chain: &signer) {
-        assert!(
-            signer::address_of(chain) == @initia_std,
-            error::permission_denied(EUNAUTHORIZED)
-        );
-    }
-
-    #[test_only]
-    public fun init_module_for_test() {
-        init_module(&initia_std::account::create_signer_for_test(@initia_std))
-    }
-
-    #[test_only]
-    fun initialized_coin(
-        account: &signer, symbol: String
-    ): (coin::BurnCapability, coin::FreezeCapability, coin::MintCapability) {
-        let (mint_cap, burn_cap, freeze_cap, _) =
-            coin::initialize_and_generate_extend_ref(
-                account,
-                option::none(),
-                string::utf8(b""),
-                symbol,
-                6,
-                string::utf8(b""),
-                string::utf8(b"")
-            );
-
-        return (burn_cap, freeze_cap, mint_cap)
-    }
-
-    #[test(chain = @0x1)]
-    fun end_to_end(chain: signer) acquires ModuleStore, Pool {
-        init_module(&chain);
-        initia_std::primary_fungible_store::init_module_for_test();
-
-        let chain_addr = signer::address_of(&chain);
-        let (_, _, a_mint_cap) = initialized_coin(&chain, string::utf8(b"a"));
-        let (_, _, b_mint_cap) = initialized_coin(&chain, string::utf8(b"b"));
-        coin::mint_to(&a_mint_cap, chain_addr, 1000000000);
-        coin::mint_to(&b_mint_cap, chain_addr, 1000000000);
-        let metadata_a = coin::metadata(chain_addr, string::utf8(b"a"));
-        let metadata_b = coin::metadata(chain_addr, string::utf8(b"b"));
-        create_pool_script(
-            &chain,
-            string::utf8(b"lp"),
-            string::utf8(b"lp"),
-            bigdecimal::from_ratio_u64(5, 10000),
-            vector[metadata_a, metadata_b],
-            vector[100000000, 100000000],
-            6000
-        );
-        let metadata_lp = coin::metadata(chain_addr, string::utf8(b"lp"));
-        let pool = object::convert<Metadata, Pool>(metadata_lp);
-
-        assert!(
-            coin::balance(chain_addr, metadata_lp) == 200000000,
-            0
-        );
-        assert!(
-            coin::balance(chain_addr, metadata_a) == 900000000,
-            0
-        );
-        assert!(
-            coin::balance(chain_addr, metadata_b) == 900000000,
-            0
-        );
-        provide_liquidity_script(
-            &chain,
-            pool,
-            vector[100000000, 100000000],
-            option::none()
-        );
-        assert!(
-            coin::balance(chain_addr, metadata_lp) == 400000000,
-            1
-        );
-        assert!(
-            coin::balance(chain_addr, metadata_a) == 800000000,
-            1
-        );
-        assert!(
-            coin::balance(chain_addr, metadata_b) == 800000000,
-            1
-        );
-        withdraw_liquidity_script(
-            &chain,
-            pool,
-            200000000,
-            vector[option::none(), option::none()]
-        );
-        assert!(
-            coin::balance(chain_addr, metadata_lp) == 200000000,
-            2
-        );
-        assert!(
-            coin::balance(chain_addr, metadata_a) == 900000000,
-            2
-        );
-        assert!(
-            coin::balance(chain_addr, metadata_b) == 900000000,
-            2
-        );
-
-        let offer_coin = coin::withdraw(&chain, metadata_a, 1000000);
-        let return_coin = swap(pool, offer_coin, metadata_b, option::none());
-        let return_amount = fungible_asset::amount(&return_coin);
-        assert!(return_amount == 999177, 3);
-
-        coin::deposit(chain_addr, return_coin);
-    }
-
-    #[test(chain = @0x1)]
-    fun single_asset_withdraw_test(chain: signer) acquires ModuleStore, Pool {
-        init_module(&chain);
-        initia_std::primary_fungible_store::init_module_for_test();
-
-        let chain_addr = signer::address_of(&chain);
-        let (_, _, a_mint_cap) = initialized_coin(&chain, string::utf8(b"a"));
-        let (_, _, b_mint_cap) = initialized_coin(&chain, string::utf8(b"b"));
-        coin::mint_to(&a_mint_cap, chain_addr, 1000000000);
-        coin::mint_to(&b_mint_cap, chain_addr, 1000000000);
-        let metadata_a = coin::metadata(chain_addr, string::utf8(b"a"));
-        let metadata_b = coin::metadata(chain_addr, string::utf8(b"b"));
-        create_pool_script(
-            &chain,
-            string::utf8(b"lp"),
-            string::utf8(b"lp"),
-            bigdecimal::zero(),
-            vector[metadata_a, metadata_b],
-            vector[100000000, 100000000],
-            6000
-        );
-
-        let metadata_lp = coin::metadata(chain_addr, string::utf8(b"lp"));
-        let pool = object::convert<Metadata, Pool>(metadata_lp);
-
-        let liquidity_before = coin::balance(chain_addr, metadata_lp);
-        provide_liquidity_script(
-            &chain,
-            pool,
-            vector[100000000, 0],
-            option::none()
-        );
-        let liquidity_after = coin::balance(chain_addr, metadata_lp);
-
-        single_asset_withdraw_liquidity_script(
-            &chain,
-            pool,
-            metadata_a,
-            liquidity_after - liquidity_before,
-            option::none()
-        );
-
-        // theoretically it should be 100000000, 100000000 but reduce 1 from return amount because of rounding error
-        assert!(
-            get_pool(pool).coin_balances == vector[100000001, 100000000],
-            0
-        );
-    }
-
-    #[test(chain = @0x1)]
-    fun imbalance_withdraw_test(chain: signer) acquires ModuleStore, Pool {
-        init_module(&chain);
-        initia_std::primary_fungible_store::init_module_for_test();
-
-        let chain_addr = signer::address_of(&chain);
-        let (_, _, a_mint_cap) = initialized_coin(&chain, string::utf8(b"a"));
-        let (_, _, b_mint_cap) = initialized_coin(&chain, string::utf8(b"b"));
-        coin::mint_to(&a_mint_cap, chain_addr, 1000000000);
-        coin::mint_to(&b_mint_cap, chain_addr, 1000000000);
-        let metadata_a = coin::metadata(chain_addr, string::utf8(b"a"));
-        let metadata_b = coin::metadata(chain_addr, string::utf8(b"b"));
-        create_pool_script(
-            &chain,
-            string::utf8(b"lp"),
-            string::utf8(b"lp"),
-            bigdecimal::zero(),
-            vector[metadata_a, metadata_b],
-            vector[100000000, 100000000],
-            6000
-        );
-
-        let metadata_lp = coin::metadata(chain_addr, string::utf8(b"lp"));
-        let pool = object::convert<Metadata, Pool>(metadata_lp);
-
-        let liquidity_before = coin::balance(chain_addr, metadata_lp);
-        provide_liquidity_script(
-            &chain,
-            pool,
-            vector[100000000, 50000000],
-            option::none()
-        );
-
-        imbalance_withdraw_liquidity_script(
-            &chain,
-            pool,
-            vector[100000000, 50000000],
-            option::none()
-        );
-
-        let liquidity_after = coin::balance(chain_addr, metadata_lp);
-
-        // theoretically it should be same but reduce 1 from return amount because of rounding error
-        assert!(liquidity_before == liquidity_after + 1, 0);
-    }
-}