create-dubhe 0.0.8 → 0.0.9

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

@@ -0,0 +1,2795 @@
+module initia_std::dex {
+    use std::event::Self;
+    use std::option::{Self, Option};
+    use std::error;
+    use std::signer;
+    use std::vector;
+
+    use initia_std::object::{Self, Object, ExtendRef};
+    use initia_std::block::get_block_info;
+    use initia_std::fungible_asset::{Self, Metadata, FungibleAsset, FungibleStore};
+    use initia_std::primary_fungible_store;
+    use initia_std::string::{Self, String};
+    use initia_std::table::{Self, Table};
+    use initia_std::coin;
+    use initia_std::bigdecimal::{Self, BigDecimal};
+    use initia_std::biguint;
+
+    /// Pool configuration
+    struct Config has key {
+        extend_ref: ExtendRef,
+        weights: Weights,
+        swap_fee_rate: BigDecimal
+    }
+
+    struct Pool has key {
+        coin_a_store: Object<FungibleStore>,
+        coin_b_store: Object<FungibleStore>
+    }
+
+    struct FlashSwapLock has key {
+        coin_a_borrow_amount: u64,
+        coin_b_borrow_amount: u64
+    }
+
+    /// FlashSwapReceipt is following the hot potato pattern, so the borrower
+    /// need to pass the created FlashSwapReceipt object to this contract to
+    /// destruct it.
+    ///
+    /// https://move-book.com/programmability/hot-potato-pattern.html
+    struct FlashSwapReceipt {
+        pair_addr: address
+    }
+
+    struct Weights has copy, drop, store {
+        weights_before: Weight,
+        weights_after: Weight
+    }
+
+    struct Weight has copy, drop, store {
+        coin_a_weight: BigDecimal,
+        coin_b_weight: BigDecimal,
+        timestamp: u64
+    }
+
+    /// Key for pair
+    struct PairKey has copy, drop {
+        coin_a: address,
+        coin_b: address,
+        liquidity_token: address
+    }
+
+    struct PairResponse has copy, drop, store {
+        coin_a: address,
+        coin_b: address,
+        liquidity_token: address,
+        weights: Weights,
+        swap_fee_rate: BigDecimal
+    }
+
+    struct PairByDenomResponse has copy, drop, store {
+        coin_a: String,
+        coin_b: String,
+        liquidity_token: String,
+        weights: Weights,
+        swap_fee_rate: BigDecimal
+    }
+
+    /// Coin capabilities
+    struct CoinCapabilities has key {
+        burn_cap: coin::BurnCapability,
+        freeze_cap: coin::FreezeCapability,
+        mint_cap: coin::MintCapability
+    }
+
+    #[event]
+    /// Event emitted when provide liquidity.
+    struct ProvideEvent has drop, store {
+        coin_a: address,
+        coin_b: address,
+        liquidity_token: address,
+        coin_a_amount: u64,
+        coin_b_amount: u64,
+        liquidity: u64
+    }
+
+    #[event]
+    /// Event emitted when withdraw liquidity.
+    struct WithdrawEvent has drop, store {
+        coin_a: address,
+        coin_b: address,
+        liquidity_token: address,
+        coin_a_amount: u64,
+        coin_b_amount: u64,
+        liquidity: u64
+    }
+
+    #[event]
+    /// Event emitted when swap token.
+    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 SingleAssetProvideEvent has drop, store {
+        coin_a: address,
+        coin_b: address,
+        liquidity_token: address,
+        provide_coin: address,
+        provide_amount: u64,
+        fee_amount: u64,
+        liquidity: u64
+    }
+
+    #[event]
+    struct FlashSwapEvent has drop, store {
+        offer_coin: address,
+        return_coin: address,
+        liquidity_token: address,
+        offer_amount: u64,
+        return_amount: u64,
+        fee_amount: u64
+    }
+
+    struct PoolInfoResponse has drop {
+        coin_a_amount: u64,
+        coin_b_amount: u64,
+        total_share: u128
+    }
+
+    struct ConfigResponse has drop {
+        weights: Weights,
+        swap_fee_rate: BigDecimal
+    }
+
+    struct CurrentWeightResponse has drop {
+        coin_a_weight: BigDecimal,
+        coin_b_weight: BigDecimal
+    }
+
+    struct PairMetadataResponse has drop {
+        coin_a_metadata: Object<Metadata>,
+        coin_b_metadata: Object<Metadata>
+    }
+
+    struct PairDenomResponse has drop {
+        coin_a_denom: String,
+        coin_b_denom: String
+    }
+
+    #[event]
+    struct CreatePairEvent has drop, store {
+        coin_a: address,
+        coin_b: address,
+        liquidity_token: address,
+        weights: Weights,
+        swap_fee_rate: BigDecimal
+    }
+
+    #[event]
+    struct SwapFeeUpdateEvent has drop, store {
+        coin_a: address,
+        coin_b: address,
+        liquidity_token: address,
+        swap_fee_rate: BigDecimal
+    }
+
+    /// Module store for storing pair infos
+    struct ModuleStore has key {
+        pairs: Table<PairKey, PairResponse>,
+        pair_count: u64
+    }
+
+    // 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;
+
+    // Cannot create pair with the same coin type
+    const ESAME_COIN_TYPE: u64 = 19;
+
+    /// Zero amount in the swap simulation is not allowed
+    const EZERO_AMOUNT_IN: u64 = 20;
+
+    /// Weights sum must be 1.0
+    const EINVALID_WEIGHTS: u64 = 21;
+
+    /// Pool is locked by flash swap
+    const EPOOL_LOCKED: u64 = 22;
+
+    /// Failed to repay flash swap due to incorrect repay amount
+    const EFAILED_TO_REPAY_FLASH_SWAP: u64 = 23;
+
+    // Constants
+
+    const MAX_LIMIT: u8 = 30;
+
+    // TODO - find the reasonable precision
+    /// Result Precision of `pow` and `ln` function
+    const PRECISION: u64 = 100000;
+
+    #[view]
+    public fun get_pair_metadata(pair: Object<Config>): PairMetadataResponse acquires Pool {
+        let pool = borrow_global<Pool>(object::object_address(&pair));
+        let coin_a_metadata = fungible_asset::store_metadata(pool.coin_a_store);
+        let coin_b_metadata = fungible_asset::store_metadata(pool.coin_b_store);
+
+        PairMetadataResponse { coin_a_metadata, coin_b_metadata }
+    }
+
+    #[view]
+    public fun get_pair_denom(pair: Object<Config>): PairDenomResponse acquires Pool {
+        let pair_metadata = get_pair_metadata(pair);
+
+        PairDenomResponse {
+            coin_a_denom: coin::metadata_to_denom(pair_metadata.coin_a_metadata),
+            coin_b_denom: coin::metadata_to_denom(pair_metadata.coin_b_metadata)
+        }
+    }
+
+    #[view]
+    /// Calculate spot price
+    /// https://balancer.fi/whitepaper.pdf (2)
+    public fun get_spot_price(
+        pair: Object<Config>, base_coin: Object<Metadata>
+    ): BigDecimal acquires Config, Pool, FlashSwapLock {
+        let (coin_a_pool, coin_b_pool, coin_a_weight, coin_b_weight, _) =
+            pool_info(pair, false);
+
+        let pair_key = generate_pair_key(pair);
+        let base_addr = object::object_address(&base_coin);
+        assert!(
+            base_addr == pair_key.coin_a || base_addr == pair_key.coin_b,
+            error::invalid_argument(ECOIN_TYPE)
+        );
+        let is_base_a = base_addr == pair_key.coin_a;
+        let (base_pool, quote_pool, base_weight, quote_weight) =
+            if (is_base_a) {
+                (coin_a_pool, coin_b_pool, coin_a_weight, coin_b_weight)
+            } else {
+                (coin_b_pool, coin_a_pool, coin_b_weight, coin_a_weight)
+            };
+
+        bigdecimal::div(
+            bigdecimal::mul_by_u64(base_weight, quote_pool),
+            bigdecimal::mul_by_u64(quote_weight, base_pool)
+        )
+    }
+
+    #[view]
+    public fun get_spot_price_by_denom(
+        pair_denom: String, base_coin: String
+    ): BigDecimal acquires Config, Pool, FlashSwapLock {
+        let pair_metadata = coin::denom_to_metadata(pair_denom);
+        let base_metadata = coin::denom_to_metadata(base_coin);
+        get_spot_price(object::convert(pair_metadata), base_metadata)
+    }
+
+    #[view]
+    /// Return swap simulation result
+    public fun get_swap_simulation(
+        pair: Object<Config>, offer_metadata: Object<Metadata>, offer_amount: u64
+    ): u64 acquires Config, Pool, FlashSwapLock {
+        let (return_amount, _fee_amount) =
+            get_swap_simulation_with_fee(pair, offer_metadata, offer_amount);
+        return_amount
+    }
+
+    #[view]
+    /// Return swap simulation result
+    public fun get_swap_simulation_with_fee(
+        pair: Object<Config>, offer_metadata: Object<Metadata>, offer_amount: u64
+    ): (u64, u64) acquires Config, Pool, FlashSwapLock {
+        let pair_key = generate_pair_key(pair);
+        let offer_address = object::object_address(&offer_metadata);
+        assert!(
+            offer_address == pair_key.coin_a || offer_address == pair_key.coin_b,
+            error::invalid_argument(ECOIN_TYPE)
+        );
+        let is_offer_a = offer_address == pair_key.coin_a;
+        let (pool_a, pool_b, weight_a, weight_b, swap_fee_rate) = pool_info(pair, true);
+        let (offer_pool, return_pool, offer_weight, return_weight) =
+            if (is_offer_a) {
+                (pool_a, pool_b, weight_a, weight_b)
+            } else {
+                (pool_b, pool_a, weight_b, weight_a)
+            };
+
+        swap_simulation(
+            offer_pool,
+            return_pool,
+            offer_weight,
+            return_weight,
+            offer_amount,
+            swap_fee_rate
+        )
+    }
+
+    #[view]
+    public fun get_swap_simulation_by_denom(
+        pair_denom: String, offer_denom: String, offer_amount: u64
+    ): u64 acquires Config, Pool, FlashSwapLock {
+        let pair_metadata = coin::denom_to_metadata(pair_denom);
+        let offer_metadata = coin::denom_to_metadata(offer_denom);
+        get_swap_simulation(
+            object::convert(pair_metadata),
+            offer_metadata,
+            offer_amount
+        )
+    }
+
+    #[view]
+    /// Return swap simulation result
+    public fun get_swap_simulation_given_out(
+        pair: Object<Config>, offer_metadata: Object<Metadata>, return_amount: u64
+    ): u64 acquires Config, Pool, FlashSwapLock {
+        let pair_key = generate_pair_key(pair);
+        let offer_address = object::object_address(&offer_metadata);
+        assert!(
+            offer_address == pair_key.coin_a || offer_address == pair_key.coin_b,
+            error::invalid_argument(ECOIN_TYPE)
+        );
+        let is_offer_a = offer_address == pair_key.coin_a;
+        let (pool_a, pool_b, weight_a, weight_b, swap_fee_rate) = pool_info(pair, true);
+        let (offer_pool, return_pool, offer_weight, return_weight) =
+            if (is_offer_a) {
+                (pool_a, pool_b, weight_a, weight_b)
+            } else {
+                (pool_b, pool_a, weight_b, weight_a)
+            };
+        let (offer_amount, _fee_amount) =
+            swap_simulation_given_out(
+                offer_pool,
+                return_pool,
+                offer_weight,
+                return_weight,
+                return_amount,
+                swap_fee_rate
+            );
+
+        offer_amount
+    }
+
+    #[view]
+    public fun get_swap_simulation_given_out_by_denom(
+        pair_denom: String, offer_denom: String, return_amount: u64
+    ): u64 acquires Config, Pool, FlashSwapLock {
+        let pair_metadata = coin::denom_to_metadata(pair_denom);
+        let offer_metadata = coin::denom_to_metadata(offer_denom);
+        get_swap_simulation_given_out(
+            object::convert(pair_metadata),
+            offer_metadata,
+            return_amount
+        )
+    }
+
+    #[view]
+    public fun get_provide_simulation(
+        pair: Object<Config>, coin_a_amount_in: u64, coin_b_amount_in: u64
+    ): u64 acquires Pool, FlashSwapLock {
+        let pool_addr = object::object_address(&pair);
+        let pool = borrow_global<Pool>(pool_addr);
+
+        calculate_provide_liquidity_return_amount(
+            pool, pair, coin_a_amount_in, coin_b_amount_in
+        )
+    }
+
+    #[view]
+    public fun get_single_asset_provide_simulation(
+        pair: Object<Config>, offer_asset_metadata: Object<Metadata>, amount_in: u64
+    ): u64 acquires Config, Pool, FlashSwapLock {
+        let pair_addr = object::object_address(&pair);
+        let pool = borrow_global<Pool>(pair_addr);
+
+        let (liquidity_amount, _, _) =
+            calculate_single_asset_provide_liquidity_return_amount(
+                pool, pair, offer_asset_metadata, amount_in
+            );
+
+        liquidity_amount
+    }
+
+    #[view]
+    /// get pool info
+    public fun get_pool_info(pair: Object<Config>): PoolInfoResponse acquires Pool, FlashSwapLock {
+        let pair_addr = object::object_address(&pair);
+        let pool = borrow_global<Pool>(pair_addr);
+        let (pool_coin_a, pool_coin_b) = pool_amounts(pool, pair_addr);
+        PoolInfoResponse {
+            coin_a_amount: pool_coin_a,
+            coin_b_amount: pool_coin_b,
+            total_share: option::extract(&mut fungible_asset::supply(pair))
+        }
+    }
+
+    #[view]
+    /// get pool info
+    public fun get_pool_info_by_denom(
+        pair_denom: String
+    ): PoolInfoResponse acquires Pool, FlashSwapLock {
+        let pair_metadata = coin::denom_to_metadata(pair_denom);
+        get_pool_info(object::convert(pair_metadata))
+    }
+
+    #[view]
+    /// get config
+    public fun get_config(pair: Object<Config>): ConfigResponse acquires Config {
+        let pair_addr = object::object_address(&pair);
+        let config = borrow_global<Config>(pair_addr);
+
+        ConfigResponse { weights: config.weights, swap_fee_rate: config.swap_fee_rate }
+    }
+
+    #[view]
+    /// get config
+    public fun get_config_by_denom(pair_denom: String): ConfigResponse acquires Config {
+        let pair_metadata = coin::denom_to_metadata(pair_denom);
+        get_config(object::convert(pair_metadata))
+    }
+
+    #[view]
+    public fun get_current_weight(pair: Object<Config>): CurrentWeightResponse acquires Config {
+        let pair_addr = object::object_address(&pair);
+        let config = borrow_global<Config>(pair_addr);
+        let (coin_a_weight, coin_b_weight) = get_weight(&config.weights);
+        CurrentWeightResponse { coin_a_weight, coin_b_weight }
+    }
+
+    #[view]
+    public fun get_current_weight_by_denom(
+        pair_denom: String
+    ): CurrentWeightResponse acquires Config {
+        let pair_metadata = coin::denom_to_metadata(pair_denom);
+        get_current_weight(object::convert(pair_metadata))
+    }
+
+    #[view]
+    // get all kinds of pair
+    // return vector of PairResponse
+    public fun get_all_pairs(
+        coin_a_start_after: Option<address>,
+        coin_b_start_after: Option<address>,
+        liquidity_token_start_after: Option<address>,
+        limit: u8
+    ): vector<PairResponse> acquires ModuleStore {
+        if (limit > MAX_LIMIT) {
+            limit = MAX_LIMIT;
+        };
+
+        assert!(
+            option::is_some(&coin_a_start_after)
+                == option::is_some(&coin_b_start_after)
+                && option::is_some(&coin_b_start_after)
+                    == option::is_some(&liquidity_token_start_after),
+            ESTART_AFTER
+        );
+
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+
+        let start_after =
+            if (option::is_some(&coin_a_start_after)) {
+                option::some(
+                    PairKey {
+                        coin_a: option::extract(&mut coin_a_start_after),
+                        coin_b: option::extract(&mut coin_b_start_after),
+                        liquidity_token: option::extract(
+                            &mut liquidity_token_start_after
+                        )
+                    }
+                )
+            } else {
+                option::some(
+                    PairKey { coin_a: @0x0, coin_b: @0x0, liquidity_token: @0x0 }
+                )
+            };
+
+        let res = vector[];
+        let pairs_iter = table::iter(
+            &module_store.pairs,
+            start_after,
+            option::none(),
+            1
+        );
+
+        while (vector::length(&res) < (limit as u64)
+            && table::prepare<PairKey, PairResponse>(pairs_iter)) {
+            let (key, value) = table::next<PairKey, PairResponse>(pairs_iter);
+            if (&key != option::borrow(&start_after)) {
+                vector::push_back(&mut res, *value)
+            }
+        };
+
+        res
+    }
+
+    #[view]
+    // get all kinds of pair
+    // return vector of PairResponse
+    public fun get_all_pairs_by_denom(
+        coin_a_start_after: Option<String>,
+        coin_b_start_after: Option<String>,
+        liquidity_token_start_after: Option<String>,
+        limit: u8
+    ): vector<PairByDenomResponse> acquires ModuleStore {
+        if (limit > MAX_LIMIT) {
+            limit = MAX_LIMIT;
+        };
+
+        assert!(
+            option::is_some(&coin_a_start_after)
+                == option::is_some(&coin_b_start_after)
+                && option::is_some(&coin_b_start_after)
+                    == option::is_some(&liquidity_token_start_after),
+            ESTART_AFTER
+        );
+
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+
+        let start_after =
+            if (option::is_some(&coin_a_start_after)) {
+                let coin_a_start_after =
+                    coin::denom_to_metadata(option::extract(&mut coin_a_start_after));
+                let coin_b_start_after =
+                    coin::denom_to_metadata(option::extract(&mut coin_b_start_after));
+                let liquidity_token_start_after =
+                    coin::denom_to_metadata(
+                        option::extract(&mut liquidity_token_start_after)
+                    );
+                option::some(
+                    PairKey {
+                        coin_a: object::object_address(&coin_a_start_after),
+                        coin_b: object::object_address(&coin_b_start_after),
+                        liquidity_token: object::object_address(
+                            &liquidity_token_start_after
+                        )
+                    }
+                )
+            } else {
+                option::some(
+                    PairKey { coin_a: @0x0, coin_b: @0x0, liquidity_token: @0x0 }
+                )
+            };
+
+        let res = vector[];
+        let pairs_iter = table::iter(
+            &module_store.pairs,
+            start_after,
+            option::none(),
+            1
+        );
+
+        while (vector::length(&res) < (limit as u64)
+            && table::prepare<PairKey, PairResponse>(pairs_iter)) {
+            let (key, value) = table::next<PairKey, PairResponse>(pairs_iter);
+            if (&key != option::borrow(&start_after)) {
+                vector::push_back(
+                    &mut res,
+                    PairByDenomResponse {
+                        coin_a: coin::metadata_to_denom(
+                            object::address_to_object(value.coin_a)
+                        ),
+                        coin_b: coin::metadata_to_denom(
+                            object::address_to_object(value.coin_b)
+                        ),
+                        liquidity_token: coin::metadata_to_denom(
+                            object::address_to_object(value.liquidity_token)
+                        ),
+                        weights: value.weights,
+                        swap_fee_rate: value.swap_fee_rate
+                    }
+                )
+            }
+        };
+
+        res
+    }
+
+    #[view]
+    // get pairs by coin types
+    // return vector of PairResponse
+    public fun get_pairs(
+        coin_a: address,
+        coin_b: address,
+        start_after: Option<address>,
+        limit: u8
+    ): vector<PairResponse> acquires ModuleStore {
+        if (limit > MAX_LIMIT) {
+            limit = MAX_LIMIT;
+        };
+
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+
+        let start_after =
+            if (option::is_some(&start_after)) {
+                option::some(
+                    PairKey {
+                        coin_a,
+                        coin_b,
+                        liquidity_token: option::extract(&mut start_after)
+                    }
+                )
+            } else {
+                option::some(PairKey { coin_a, coin_b, liquidity_token: @0x0 })
+            };
+
+        let res = vector[];
+        let pairs_iter = table::iter(
+            &module_store.pairs,
+            start_after,
+            option::none(),
+            1
+        );
+
+        while (vector::length(&res) < (limit as u64)
+            && table::prepare<PairKey, PairResponse>(pairs_iter)) {
+            let (key, value) = table::next<PairKey, PairResponse>(pairs_iter);
+            if (coin_a != key.coin_a || coin_b != key.coin_b)
+                break;
+            if (&key != option::borrow(&start_after)) {
+                vector::push_back(&mut res, *value)
+            }
+        };
+
+        res
+    }
+
+    // Query functions
+
+    public fun get_coin_a_amount_from_pool_info_response(
+        res: &PoolInfoResponse
+    ): u64 {
+        res.coin_a_amount
+    }
+
+    public fun get_coin_b_amount_from_pool_info_response(
+        res: &PoolInfoResponse
+    ): u64 {
+        res.coin_b_amount
+    }
+
+    public fun get_total_share_from_pool_info_response(
+        res: &PoolInfoResponse
+    ): u128 {
+        res.total_share
+    }
+
+    public fun get_swap_fee_rate_from_config_response(
+        res: &ConfigResponse
+    ): BigDecimal {
+        res.swap_fee_rate
+    }
+
+    public fun get_weight_before_from_config_response(
+        res: &ConfigResponse
+    ): Weight {
+        res.weights.weights_before
+    }
+
+    public fun get_weight_after_from_config_response(res: &ConfigResponse): Weight {
+        res.weights.weights_after
+    }
+
+    public fun get_coin_a_weight_from_weight(weight: &Weight): BigDecimal {
+        weight.coin_a_weight
+    }
+
+    public fun get_coin_b_weight_from_weight(weight: &Weight): BigDecimal {
+        weight.coin_b_weight
+    }
+
+    public fun get_timestamp_from_weight(weight: &Weight): u64 {
+        weight.timestamp
+    }
+
+    public fun unpack_pair_response(
+        pair_response: &PairResponse
+    ): (address, address, address, Weights, BigDecimal) {
+        (
+            pair_response.coin_a,
+            pair_response.coin_b,
+            pair_response.liquidity_token,
+            pair_response.weights,
+            pair_response.swap_fee_rate
+        )
+    }
+
+    public fun unpack_current_weight_response(
+        current_weight_response: &CurrentWeightResponse
+    ): (BigDecimal, BigDecimal) {
+        (current_weight_response.coin_a_weight, current_weight_response.coin_b_weight)
+    }
+
+    /// Check signer is chain
+    fun check_chain_permission(chain: &signer) {
+        assert!(
+            signer::address_of(chain) == @initia_std,
+            error::permission_denied(EUNAUTHORIZED)
+        );
+    }
+
+    fun init_module(chain: &signer) {
+        move_to(
+            chain,
+            ModuleStore {
+                pairs: table::new<PairKey, PairResponse>(),
+                pair_count: 0
+            }
+        );
+    }
+
+    public entry fun create_pair_script(
+        creator: &signer,
+        name: String,
+        symbol: String,
+        swap_fee_rate: BigDecimal,
+        coin_a_weight: BigDecimal,
+        coin_b_weight: BigDecimal,
+        coin_a_metadata: Object<Metadata>,
+        coin_b_metadata: Object<Metadata>,
+        coin_a_amount: u64,
+        coin_b_amount: u64
+    ) acquires CoinCapabilities, Config, Pool, ModuleStore, FlashSwapLock {
+        let (_, timestamp) = get_block_info();
+        let weights = Weights {
+            weights_before: Weight { coin_a_weight, coin_b_weight, timestamp },
+            weights_after: Weight { coin_a_weight, coin_b_weight, timestamp }
+        };
+
+        let coin_a = coin::withdraw(creator, coin_a_metadata, coin_a_amount);
+        let coin_b = coin::withdraw(creator, coin_b_metadata, coin_b_amount);
+
+        let liquidity_token =
+            create_pair(
+                creator,
+                name,
+                symbol,
+                swap_fee_rate,
+                coin_a,
+                coin_b,
+                weights
+            );
+        coin::deposit(signer::address_of(creator), liquidity_token);
+    }
+
+    /// Create LBP pair
+    /// permission check will be done in LP coin initialize
+    /// only LP struct owner can initialize
+    public entry fun create_lbp_pair_script(
+        creator: &signer,
+        name: String,
+        symbol: String,
+        swap_fee_rate: BigDecimal,
+        start_time: u64,
+        coin_a_start_weight: BigDecimal,
+        coin_b_start_weight: BigDecimal,
+        end_time: u64,
+        coin_a_end_weight: BigDecimal,
+        coin_b_end_weight: BigDecimal,
+        coin_a_metadata: Object<Metadata>,
+        coin_b_metadata: Object<Metadata>,
+        coin_a_amount: u64,
+        coin_b_amount: u64
+    ) acquires CoinCapabilities, Config, ModuleStore, Pool, FlashSwapLock {
+        let (_, timestamp) = get_block_info();
+        assert!(
+            start_time > timestamp,
+            error::invalid_argument(ELBP_START_TIME)
+        );
+        assert!(
+            end_time > start_time,
+            error::invalid_argument(EWEIGHTS_TIMESTAMP)
+        );
+        let weights = Weights {
+            weights_before: Weight {
+                coin_a_weight: coin_a_start_weight,
+                coin_b_weight: coin_b_start_weight,
+                timestamp: start_time
+            },
+            weights_after: Weight {
+                coin_a_weight: coin_a_end_weight,
+                coin_b_weight: coin_b_end_weight,
+                timestamp: end_time
+            }
+        };
+
+        let coin_a = coin::withdraw(creator, coin_a_metadata, coin_a_amount);
+        let coin_b = coin::withdraw(creator, coin_b_metadata, coin_b_amount);
+
+        let liquidity_token =
+            create_pair(
+                creator,
+                name,
+                symbol,
+                swap_fee_rate,
+                coin_a,
+                coin_b,
+                weights
+            );
+        coin::deposit(signer::address_of(creator), liquidity_token);
+    }
+
+    fun max_fee_rate(): BigDecimal {
+        bigdecimal::from_ratio_u64(5, 100)
+    }
+
+    /// update swap fee rate
+    public entry fun update_swap_fee_rate(
+        chain: &signer, pair: Object<Config>, swap_fee_rate: BigDecimal
+    ) acquires Config, Pool, ModuleStore {
+        check_chain_permission(chain);
+
+        let config = borrow_global_mut<Config>(object::object_address(&pair));
+        assert!(
+            bigdecimal::le(swap_fee_rate, max_fee_rate()),
+            error::invalid_argument(EOUT_OF_SWAP_FEE_RATE_RANGE)
+        );
+
+        config.swap_fee_rate = swap_fee_rate;
+        let pair_key = generate_pair_key(pair);
+
+        // update PairResponse
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        let pair_response = table::borrow_mut(&mut module_store.pairs, pair_key);
+
+        pair_response.swap_fee_rate = swap_fee_rate;
+
+        // emit event
+        event::emit<SwapFeeUpdateEvent>(
+            SwapFeeUpdateEvent {
+                coin_a: pair_key.coin_a,
+                coin_b: pair_key.coin_b,
+                liquidity_token: pair_key.liquidity_token,
+                swap_fee_rate
+            }
+        );
+    }
+
+    /// script of `provide_liquidity_from_coin_store`
+    public entry fun provide_liquidity_script(
+        account: &signer,
+        pair: Object<Config>,
+        coin_a_amount_in: u64,
+        coin_b_amount_in: u64,
+        min_liquidity: Option<u64>
+    ) acquires CoinCapabilities, Config, Pool, FlashSwapLock {
+        provide_liquidity_from_coin_store(
+            account,
+            pair,
+            coin_a_amount_in,
+            coin_b_amount_in,
+            min_liquidity
+        );
+    }
+
+    /// Provide liquidity with 0x1::coin::CoinStore coins
+    public fun provide_liquidity_from_coin_store(
+        account: &signer,
+        pair: Object<Config>,
+        coin_a_amount_in: u64,
+        coin_b_amount_in: u64,
+        min_liquidity: Option<u64>
+    ): (u64, u64, u64) acquires CoinCapabilities, Config, Pool, FlashSwapLock {
+        let pair_addr = object::object_address(&pair);
+        let pool = borrow_global<Pool>(pair_addr);
+        let (coin_a_amount, coin_b_amount) = pool_amounts(pool, pair_addr);
+        let total_share = option::extract(&mut fungible_asset::supply(pair));
+
+        // calculate the best coin amount
+        let (coin_a, coin_b) =
+            if (total_share == 0) {
+                (
+                    coin::withdraw(
+                        account,
+                        fungible_asset::store_metadata(pool.coin_a_store),
+                        coin_a_amount_in
+                    ),
+                    coin::withdraw(
+                        account,
+                        fungible_asset::store_metadata(pool.coin_b_store),
+                        coin_b_amount_in
+                    )
+                )
+            } else {
+                let coin_a_share_ratio =
+                    bigdecimal::from_ratio_u64(coin_a_amount_in, coin_a_amount);
+                let coin_b_share_ratio =
+                    bigdecimal::from_ratio_u64(coin_b_amount_in, coin_b_amount);
+                if (bigdecimal::gt(coin_a_share_ratio, coin_b_share_ratio)) {
+                    coin_a_amount_in = bigdecimal::mul_by_u64_truncate(
+                        coin_b_share_ratio, coin_a_amount
+                    );
+                } else {
+                    coin_b_amount_in = bigdecimal::mul_by_u64_truncate(
+                        coin_a_share_ratio, coin_b_amount
+                    );
+                };
+
+                (
+                    coin::withdraw(
+                        account,
+                        fungible_asset::store_metadata(pool.coin_a_store),
+                        coin_a_amount_in
+                    ),
+                    coin::withdraw(
+                        account,
+                        fungible_asset::store_metadata(pool.coin_b_store),
+                        coin_b_amount_in
+                    )
+                )
+            };
+
+        let liquidity_token = provide_liquidity(pair, coin_a, coin_b, min_liquidity);
+
+        let liquidity_token_amount = fungible_asset::amount(&liquidity_token);
+        coin::deposit(signer::address_of(account), liquidity_token);
+
+        (coin_a_amount_in, coin_b_amount_in, liquidity_token_amount)
+    }
+
+    /// Withdraw liquidity with liquidity token in the token store
+    public entry fun withdraw_liquidity_script(
+        account: &signer,
+        pair: Object<Config>,
+        liquidity: u64,
+        min_coin_a_amount: Option<u64>,
+        min_coin_b_amount: Option<u64>
+    ) acquires CoinCapabilities, Config, Pool, FlashSwapLock {
+        assert!(
+            liquidity != 0,
+            error::invalid_argument(EZERO_LIQUIDITY)
+        );
+
+        let addr = signer::address_of(account);
+        let liquidity_token =
+            coin::withdraw(
+                account,
+                object::convert<Config, Metadata>(pair),
+                liquidity
+            );
+        let (coin_a, coin_b) =
+            withdraw_liquidity(
+                liquidity_token,
+                min_coin_a_amount,
+                min_coin_b_amount
+            );
+
+        coin::deposit(addr, coin_a);
+        coin::deposit(addr, coin_b);
+    }
+
+    /// Swap with the coin in the coin store
+    public entry fun swap_script(
+        account: &signer,
+        pair: Object<Config>,
+        offer_coin: Object<Metadata>,
+        offer_coin_amount: u64,
+        min_return: Option<u64>
+    ) acquires Config, Pool, FlashSwapLock {
+        let offer_coin = coin::withdraw(account, offer_coin, offer_coin_amount);
+        let return_coin = swap(pair, offer_coin);
+
+        assert!(
+            option::is_none(&min_return)
+                || *option::borrow(&min_return) <= fungible_asset::amount(&return_coin),
+            error::invalid_state(EMIN_RETURN)
+        );
+
+        coin::deposit(signer::address_of(account), return_coin);
+    }
+
+    /// Single asset provide liquidity with token in the token store
+    public entry fun single_asset_provide_liquidity_script(
+        account: &signer,
+        pair: Object<Config>,
+        provide_coin: Object<Metadata>,
+        amount_in: u64,
+        min_liquidity: Option<u64>
+    ) acquires Config, CoinCapabilities, Pool, FlashSwapLock {
+        let addr = signer::address_of(account);
+        let provide_coin = coin::withdraw(account, provide_coin, amount_in);
+        let liquidity_token =
+            single_asset_provide_liquidity(pair, provide_coin, min_liquidity);
+
+        coin::deposit(addr, liquidity_token);
+    }
+
+    /// Withdraw liquidity directly
+    /// CONTRACT: not allow until LBP is ended
+    public fun withdraw_liquidity(
+        lp_token: FungibleAsset,
+        min_coin_a_amount: Option<u64>,
+        min_coin_b_amount: Option<u64>
+    ): (FungibleAsset, FungibleAsset) acquires CoinCapabilities, Config, Pool, FlashSwapLock {
+        let pair_addr = coin_address(&lp_token);
+
+        // check pool is not locked by flash swap
+        assert_pool_unlocked(pair_addr);
+
+        let pool = borrow_global<Pool>(pair_addr);
+        let config = borrow_global<Config>(pair_addr);
+        let total_share =
+            option::extract(
+                &mut fungible_asset::supply(
+                    fungible_asset::metadata_from_asset(&lp_token)
+                )
+            );
+        let (coin_a_amount, coin_b_amount) = pool_amounts(pool, pair_addr);
+        let (coin_a_store, coin_b_store) = (pool.coin_a_store, pool.coin_b_store);
+        let given_token_amount = fungible_asset::amount(&lp_token);
+        let given_share_ratio =
+            bigdecimal::from_ratio_u128((given_token_amount as u128), total_share);
+        let coin_a_amount_out =
+            bigdecimal::mul_by_u64_truncate(given_share_ratio, coin_a_amount);
+        let coin_b_amount_out =
+            bigdecimal::mul_by_u64_truncate(given_share_ratio, coin_b_amount);
+        check_lbp_ended(&config.weights);
+
+        assert!(
+            option::is_none(&min_coin_a_amount)
+                || *option::borrow(&min_coin_a_amount) <= coin_a_amount_out,
+            error::invalid_state(EMIN_WITHDRAW)
+        );
+        assert!(
+            option::is_none(&min_coin_b_amount)
+                || *option::borrow(&min_coin_b_amount) <= coin_b_amount_out,
+            error::invalid_state(EMIN_WITHDRAW)
+        );
+
+        // burn liquidity token
+        let liquidity_token_capabilities = borrow_global<CoinCapabilities>(pair_addr);
+        coin::burn(
+            &liquidity_token_capabilities.burn_cap,
+            lp_token
+        );
+
+        // emit events
+        let pair_key = generate_pair_key(object::address_to_object<Config>(pair_addr));
+        event::emit<WithdrawEvent>(
+            WithdrawEvent {
+                coin_a: pair_key.coin_a,
+                coin_b: pair_key.coin_b,
+                liquidity_token: pair_addr,
+                coin_a_amount: coin_a_amount_out,
+                coin_b_amount: coin_b_amount_out,
+                liquidity: given_token_amount
+            }
+        );
+
+        // withdraw and return the coins
+        let pair_signer = &object::generate_signer_for_extending(&config.extend_ref);
+        (
+            fungible_asset::withdraw(pair_signer, coin_a_store, coin_a_amount_out),
+            fungible_asset::withdraw(pair_signer, coin_b_store, coin_b_amount_out)
+        )
+    }
+
+    /// Single asset provide liquidity directly
+    /// CONTRACT: cannot provide more than the pool amount to prevent huge price impact
+    /// CONTRACT: not allow until LBP is ended
+    public fun single_asset_provide_liquidity(
+        pair: Object<Config>,
+        provide_coin: FungibleAsset,
+        min_liquidity_amount: Option<u64>
+    ): FungibleAsset acquires Config, CoinCapabilities, Pool, FlashSwapLock {
+        let pair_addr = object::object_address(&pair);
+
+        // check pool is not locked by flash swap
+        assert_pool_unlocked(pair_addr);
+
+        let pool = borrow_global<Pool>(pair_addr);
+
+        let provide_metadata = fungible_asset::metadata_from_asset(&provide_coin);
+        let provide_amount = fungible_asset::amount(&provide_coin);
+
+        let (liquidity, fee_amount, is_provide_a) =
+            calculate_single_asset_provide_liquidity_return_amount(
+                pool, pair, provide_metadata, provide_amount
+            );
+
+        // deposit token
+        if (is_provide_a) {
+            fungible_asset::deposit(pool.coin_a_store, provide_coin);
+        } else {
+            fungible_asset::deposit(pool.coin_b_store, provide_coin);
+        };
+
+        let pair_key = generate_pair_key(pair);
+
+        // check min liquidity assertion
+        assert!(
+            option::is_none(&min_liquidity_amount)
+                || *option::borrow(&min_liquidity_amount) <= liquidity,
+            error::invalid_state(EMIN_LIQUIDITY)
+        );
+
+        // emit events
+        event::emit<SingleAssetProvideEvent>(
+            SingleAssetProvideEvent {
+                coin_a: pair_key.coin_a,
+                coin_b: pair_key.coin_b,
+                provide_coin: object::object_address(&provide_metadata),
+                liquidity_token: pair_addr,
+                provide_amount,
+                fee_amount,
+                liquidity
+            }
+        );
+
+        // mint liquidity tokens to provider
+        let liquidity_token_capabilities = borrow_global<CoinCapabilities>(pair_addr);
+        coin::mint(
+            &liquidity_token_capabilities.mint_cap,
+            liquidity
+        )
+    }
+
+    /// Swap directly
+    public fun swap(
+        pair: Object<Config>, offer_coin: FungibleAsset
+    ): FungibleAsset acquires Config, Pool, FlashSwapLock {
+        let pair_addr = object::object_address(&pair);
+
+        // check pool is not locked by flash swap
+        assert_pool_unlocked(pair_addr);
+
+        let offer_amount = fungible_asset::amount(&offer_coin);
+        let offer_metadata = fungible_asset::metadata_from_asset(&offer_coin);
+        let offer_address = object::object_address(&offer_metadata);
+        let pair_key = generate_pair_key(pair);
+        assert!(
+            offer_address == pair_key.coin_a || offer_address == pair_key.coin_b,
+            error::invalid_argument(ECOIN_TYPE)
+        );
+        let is_offer_a = offer_address == pair_key.coin_a;
+
+        let (pool_a, pool_b, weight_a, weight_b, swap_fee_rate) = pool_info(pair, true);
+        let (
+            offer_coin_addr,
+            return_coin_addr,
+            offer_pool,
+            return_pool,
+            offer_weight,
+            return_weight
+        ) =
+            if (is_offer_a) {
+                (pair_key.coin_a, pair_key.coin_b, pool_a, pool_b, weight_a, weight_b)
+            } else {
+                (pair_key.coin_b, pair_key.coin_a, pool_b, pool_a, weight_b, weight_a)
+            };
+        let (return_amount, fee_amount) =
+            swap_simulation(
+                offer_pool,
+                return_pool,
+                offer_weight,
+                return_weight,
+                fungible_asset::amount(&offer_coin),
+                swap_fee_rate
+            );
+
+        // apply swap result to pool
+        let pool = borrow_global<Pool>(pair_addr);
+        let config = borrow_global<Config>(pair_addr);
+        let pair_signer = &object::generate_signer_for_extending(&config.extend_ref);
+        let return_coin =
+            if (is_offer_a) {
+                fungible_asset::deposit(pool.coin_a_store, offer_coin);
+                fungible_asset::withdraw(pair_signer, pool.coin_b_store, return_amount)
+            } else {
+                fungible_asset::deposit(pool.coin_b_store, offer_coin);
+                fungible_asset::withdraw(pair_signer, pool.coin_a_store, return_amount)
+            };
+
+        // emit events
+        event::emit<SwapEvent>(
+            SwapEvent {
+                offer_coin: offer_coin_addr,
+                return_coin: return_coin_addr,
+                liquidity_token: pair_addr,
+                fee_amount,
+                offer_amount,
+                return_amount
+            }
+        );
+
+        return_coin
+    }
+
+    /// FlashSwap is a special swap that allows the user to use return coin first and repay the offer coin later.
+    /// The borrower should repay the offer coin by calling `repay_flash_swap` function with FlashSwapReceipt object.
+    ///
+    /// https://move-book.com/programmability/hot-potato-pattern.html
+    public fun flash_swap(
+        pair: Object<Config>,
+        offer_coin: Object<Metadata>,
+        offer_amount: u64,
+        min_return: Option<u64>
+    ): (FungibleAsset, FlashSwapReceipt) acquires Config, Pool, FlashSwapLock {
+        let pair_addr = object::object_address(&pair);
+
+        // check pool is not locked by flash swap
+        assert_pool_unlocked(pair_addr);
+
+        // zero offer amount would be invalidated in swap_simulation
+        let (return_amount, fee_amount) =
+            get_swap_simulation_with_fee(pair, offer_coin, offer_amount);
+        assert!(
+            option::is_none(&min_return)
+                || *option::borrow(&min_return) <= return_amount,
+            error::invalid_state(EMIN_RETURN)
+        );
+
+        let pool = borrow_global<Pool>(pair_addr);
+        let pool_config = borrow_global<Config>(pair_addr);
+        let pair_signer = &object::generate_signer_for_extending(&pool_config.extend_ref);
+
+        let coin_a_metadata = fungible_asset::store_metadata(pool.coin_a_store);
+        let (return_coin_store, coin_a_borrow_amount, coin_b_borrow_amount) =
+            if (offer_coin == coin_a_metadata) {
+                (pool.coin_b_store, offer_amount, 0)
+            } else {
+                (pool.coin_a_store, 0, offer_amount)
+            };
+
+        // store flash swap to prevent recursive flash swap
+        move_to(pair_signer, FlashSwapLock { coin_a_borrow_amount, coin_b_borrow_amount });
+
+        let return_coin =
+            fungible_asset::withdraw(pair_signer, return_coin_store, return_amount);
+
+        // emit events
+        event::emit<FlashSwapEvent>(
+            FlashSwapEvent {
+                offer_coin: object::object_address(&offer_coin),
+                return_coin: coin_address(&return_coin),
+                liquidity_token: pair_addr,
+                offer_amount,
+                return_amount,
+                fee_amount
+            }
+        );
+
+        (return_coin, FlashSwapReceipt { pair_addr })
+    }
+
+    public fun repay_flash_swap(
+        repay_fa: FungibleAsset, receipt: FlashSwapReceipt
+    ) acquires Pool, FlashSwapLock {
+        let FlashSwapReceipt { pair_addr } = receipt;
+        let FlashSwapLock { coin_a_borrow_amount, coin_b_borrow_amount } =
+            move_from(pair_addr);
+
+        let pool = borrow_global<Pool>(pair_addr);
+        let (repay_amount, repay_store) =
+            if (coin_a_borrow_amount > 0) {
+                (coin_a_borrow_amount, pool.coin_a_store)
+            } else {
+                (coin_b_borrow_amount, pool.coin_b_store)
+            };
+
+        assert!(
+            fungible_asset::amount(&repay_fa) == repay_amount,
+            error::invalid_argument(EFAILED_TO_REPAY_FLASH_SWAP)
+        );
+
+        fungible_asset::deposit(repay_store, repay_fa);
+    }
+
+    /// Sum of weights must be 1
+    fun assert_weights(weights: Weights) {
+        assert!(
+            bigdecimal::eq(
+                bigdecimal::one(),
+                bigdecimal::add(
+                    weights.weights_before.coin_a_weight,
+                    weights.weights_before.coin_b_weight
+                )
+            ),
+            EINVALID_WEIGHTS
+        );
+        assert!(
+            bigdecimal::eq(
+                bigdecimal::one(),
+                bigdecimal::add(
+                    weights.weights_after.coin_a_weight,
+                    weights.weights_after.coin_b_weight
+                )
+            ),
+            EINVALID_WEIGHTS
+        );
+    }
+
+    fun assert_pool_unlocked(pair_addr: address) {
+        assert!(
+            !exists<FlashSwapLock>(pair_addr),
+            error::invalid_state(EPOOL_LOCKED)
+        );
+    }
+
+    public fun create_pair(
+        creator: &signer,
+        name: String,
+        symbol: String,
+        swap_fee_rate: BigDecimal,
+        coin_a: FungibleAsset,
+        coin_b: FungibleAsset,
+        weights: Weights
+    ): FungibleAsset acquires CoinCapabilities, Config, ModuleStore, Pool, FlashSwapLock {
+        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"")
+            );
+
+        assert_weights(weights);
+
+        assert!(
+            bigdecimal::le(swap_fee_rate, max_fee_rate()),
+            error::invalid_argument(EOUT_OF_SWAP_FEE_RATE_RANGE)
+        );
+
+        assert!(
+            coin_address(&coin_a) != coin_address(&coin_b),
+            error::invalid_argument(ESAME_COIN_TYPE)
+        );
+
+        let pair_signer = &object::generate_signer_for_extending(&extend_ref);
+        let pair_addr = signer::address_of(pair_signer);
+        // transfer pair object's ownership to initia_std
+        object::transfer_raw(creator, pair_addr, @initia_std);
+
+        let coin_a_store =
+            primary_fungible_store::create_primary_store(
+                pair_addr,
+                fungible_asset::asset_metadata(&coin_a)
+            );
+        let coin_b_store =
+            primary_fungible_store::create_primary_store(
+                pair_addr,
+                fungible_asset::asset_metadata(&coin_b)
+            );
+        let coin_a_addr = coin_address(&coin_a);
+        let coin_b_addr = coin_address(&coin_b);
+
+        move_to(pair_signer, Pool { coin_a_store, coin_b_store });
+
+        move_to(
+            pair_signer,
+            CoinCapabilities { mint_cap, freeze_cap, burn_cap }
+        );
+
+        move_to(
+            pair_signer,
+            Config {
+                extend_ref,
+                // temp weights for initial provide
+                weights: Weights {
+                    weights_before: Weight {
+                        coin_a_weight: bigdecimal::one(),
+                        coin_b_weight: bigdecimal::one(),
+                        timestamp: 0
+                    },
+                    weights_after: Weight {
+                        coin_a_weight: bigdecimal::one(),
+                        coin_b_weight: bigdecimal::one(),
+                        timestamp: 0
+                    }
+                },
+                swap_fee_rate
+            }
+        );
+
+        let liquidity_token =
+            provide_liquidity(
+                object::address_to_object<Config>(pair_addr),
+                coin_a,
+                coin_b,
+                option::none()
+            );
+
+        // update weights
+        let config = borrow_global_mut<Config>(pair_addr);
+        config.weights = weights;
+
+        // update module store
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        module_store.pair_count = module_store.pair_count + 1;
+
+        // let coin_a_type = type_info::type_name<CoinA>();
+        // let coin_b_type = type_info::type_name<CoinB>();
+        // let liquidity_token_type = type_info::type_name<LiquidityToken>();
+        let pair_key = PairKey {
+            coin_a: coin_a_addr,
+            coin_b: coin_b_addr,
+            liquidity_token: pair_addr
+        };
+
+        // add pair to table for queries
+        table::add(
+            &mut module_store.pairs,
+            pair_key,
+            PairResponse {
+                coin_a: coin_a_addr,
+                coin_b: coin_b_addr,
+                liquidity_token: pair_addr,
+                weights,
+                swap_fee_rate
+            }
+        );
+
+        // emit create pair event
+        event::emit<CreatePairEvent>(
+            CreatePairEvent {
+                coin_a: coin_a_addr,
+                coin_b: coin_b_addr,
+                liquidity_token: pair_addr,
+                weights,
+                swap_fee_rate
+            }
+        );
+
+        liquidity_token
+    }
+
+    /// Provide liquidity directly
+    /// CONTRACT: not allow until LBP is ended
+    public fun provide_liquidity(
+        pair: Object<Config>,
+        coin_a: FungibleAsset,
+        coin_b: FungibleAsset,
+        min_liquidity_amount: Option<u64>
+    ): FungibleAsset acquires Config, Pool, CoinCapabilities, FlashSwapLock {
+        let pair_addr = object::object_address(&pair);
+
+        // check pool is not locked by flash swap
+        assert_pool_unlocked(pair_addr);
+
+        let config = borrow_global<Config>(pair_addr);
+        let pool = borrow_global<Pool>(pair_addr);
+        check_lbp_ended(&config.weights);
+
+        let coin_a_amount_in = fungible_asset::amount(&coin_a);
+        let coin_b_amount_in = fungible_asset::amount(&coin_b);
+
+        let liquidity =
+            calculate_provide_liquidity_return_amount(
+                pool, pair, coin_a_amount_in, coin_b_amount_in
+            );
+
+        assert!(
+            option::is_none(&min_liquidity_amount)
+                || *option::borrow(&min_liquidity_amount) <= liquidity,
+            error::invalid_state(EMIN_LIQUIDITY)
+        );
+
+        event::emit<ProvideEvent>(
+            ProvideEvent {
+                coin_a: coin_address(&coin_a),
+                coin_b: coin_address(&coin_b),
+                liquidity_token: pair_addr,
+                coin_a_amount: coin_a_amount_in,
+                coin_b_amount: coin_b_amount_in,
+                liquidity
+            }
+        );
+
+        fungible_asset::deposit(pool.coin_a_store, coin_a);
+        fungible_asset::deposit(pool.coin_b_store, coin_b);
+
+        let liquidity_token_capabilities = borrow_global<CoinCapabilities>(pair_addr);
+        coin::mint(
+            &liquidity_token_capabilities.mint_cap,
+            liquidity
+        )
+    }
+
+    fun coin_address(fa: &FungibleAsset): address {
+        let metadata = fungible_asset::asset_metadata(fa);
+        object::object_address(&metadata)
+    }
+
+    fun check_lbp_ended(weights: &Weights) {
+        let (_, timestamp) = get_block_info();
+
+        assert!(
+            timestamp >= weights.weights_after.timestamp,
+            error::invalid_state(ELBP_NOT_ENDED)
+        )
+    }
+
+    fun generate_pair_key<T: key>(pair: Object<T>): PairKey acquires Pool {
+        let addr = object::object_address(&pair);
+        let pool = borrow_global<Pool>(addr);
+        let coin_a_metadata = fungible_asset::store_metadata(pool.coin_a_store);
+        let coin_b_metadata = fungible_asset::store_metadata(pool.coin_b_store);
+        PairKey {
+            coin_a: object::object_address(&coin_a_metadata),
+            coin_b: object::object_address(&coin_b_metadata),
+            liquidity_token: addr
+        }
+    }
+
+    /// return (coin_a_weight, coin_b_weight)
+    fun get_weight(weights: &Weights): (BigDecimal, BigDecimal) {
+        let (_, timestamp) = get_block_info();
+        if (timestamp <= weights.weights_before.timestamp) {
+            (weights.weights_before.coin_a_weight, weights.weights_before.coin_b_weight)
+        } else if (timestamp < weights.weights_after.timestamp) {
+            let interval =
+                weights.weights_after.timestamp - weights.weights_before.timestamp;
+
+            let time_diff_after = weights.weights_after.timestamp - timestamp;
+            let time_diff_before = timestamp - weights.weights_before.timestamp;
+
+            // when timestamp_before < timestamp < timestamp_after
+            // weight is linearly change from before to after
+            //
+            // weight = g * timestamp + c
+            // where g is gradient of line and c is the weight-intercept (weight value when timestamp is 0)
+            //
+            // n = (g * timestamp_before + c) * (timestamp_after - timestamp)
+            //   = g * t_b * t_a - g * t_b * t + c * t_a - c * t
+            // m = (g * timestamp_after + c) * (timestamp - timestamp_before)
+            //   = g * t_a * t - g * t_a * t_b + c * t - c * t_b
+            // l = m + n = g * t * (t_a - t_b) + c * (t_a - t_b)
+            // weight = l / (t_a - t_b) = g * t + c
+            let coin_a_m =
+                bigdecimal::mul_by_u64(
+                    weights.weights_after.coin_a_weight, time_diff_before
+                );
+            let coin_a_n =
+                bigdecimal::mul_by_u64(
+                    weights.weights_before.coin_a_weight, time_diff_after
+                );
+            let coin_a_l = bigdecimal::add(coin_a_m, coin_a_n);
+
+            let coin_b_m =
+                bigdecimal::mul_by_u64(
+                    weights.weights_after.coin_b_weight, time_diff_before
+                );
+            let coin_b_n =
+                bigdecimal::mul_by_u64(
+                    weights.weights_before.coin_b_weight, time_diff_after
+                );
+            let coin_b_l = bigdecimal::add(coin_b_m, coin_b_n);
+            (
+                bigdecimal::div_by_u64(coin_a_l, interval),
+                bigdecimal::div_by_u64(coin_b_l, interval)
+            )
+        } else {
+            (weights.weights_after.coin_a_weight, weights.weights_after.coin_b_weight)
+        }
+    }
+
+    fun calculate_provide_liquidity_return_amount(
+        pool: &Pool,
+        pair: Object<Config>,
+        coin_a_amount_in: u64,
+        coin_b_amount_in: u64
+    ): u64 acquires FlashSwapLock {
+        let pair_addr = object::object_address(&pair);
+        let (coin_a_amount, coin_b_amount) = pool_amounts(pool, pair_addr);
+        let total_share = option::extract(&mut fungible_asset::supply(pair));
+
+        if (total_share == 0) {
+            if (coin_a_amount_in > coin_b_amount_in) {
+                coin_a_amount_in
+            } else {
+                coin_b_amount_in
+            }
+        } else {
+            let coin_a_share_ratio =
+                bigdecimal::from_ratio_u64(coin_a_amount_in, coin_a_amount);
+            let coin_b_share_ratio =
+                bigdecimal::from_ratio_u64(coin_b_amount_in, coin_b_amount);
+            if (bigdecimal::gt(coin_a_share_ratio, coin_b_share_ratio)) {
+                (bigdecimal::mul_by_u128_truncate(coin_b_share_ratio, total_share) as u64)
+            } else {
+                (bigdecimal::mul_by_u128_truncate(coin_a_share_ratio, total_share) as u64)
+            }
+        }
+    }
+
+    fun calculate_single_asset_provide_liquidity_return_amount(
+        pool: &Pool,
+        pair: Object<Config>,
+        provide_metadata: Object<Metadata>,
+        amount_in: u64
+    ): (u64, u64, bool) acquires Config, FlashSwapLock {
+        let pair_addr = object::object_address(&pair);
+        let config = borrow_global<Config>(pair_addr);
+        check_lbp_ended(&config.weights);
+
+        // provide coin type must be one of coin a or coin b coin type
+        assert!(
+            provide_metadata == fungible_asset::store_metadata(pool.coin_a_store)
+                || provide_metadata
+                    == fungible_asset::store_metadata(pool.coin_b_store),
+            error::invalid_argument(ECOIN_TYPE)
+        );
+        let is_provide_a =
+            provide_metadata == fungible_asset::store_metadata(pool.coin_a_store);
+
+        let total_share = option::extract(&mut fungible_asset::supply(pair));
+        assert!(
+            total_share != 0,
+            error::invalid_state(EZERO_LIQUIDITY)
+        );
+
+        // load values for fee and increased liquidity amount calculation
+        let (coin_a_weight, coin_b_weight) = get_weight(&config.weights);
+        let (pool_amount_a, pool_amount_b) = pool_amounts(pool, pair_addr);
+        let (normalized_weight, pool_amount_in) =
+            if (is_provide_a) {
+                let normalized_weight =
+                    bigdecimal::div(
+                        coin_a_weight,
+                        bigdecimal::add(coin_a_weight, coin_b_weight)
+                    );
+
+                (normalized_weight, pool_amount_a)
+            } else {
+                let normalized_weight =
+                    bigdecimal::div(
+                        coin_b_weight,
+                        bigdecimal::add(coin_a_weight, coin_b_weight)
+                    );
+
+                (normalized_weight, pool_amount_b)
+            };
+
+        // CONTRACT: cannot provide more than the pool amount to prevent huge price impact
+        assert!(
+            pool_amount_in >= amount_in,
+            error::invalid_argument(EPRICE_IMPACT)
+        );
+
+        // compute fee amount with the assumption that we will swap (1 - normalized_weight) of amount_in
+        let adjusted_swap_amount =
+            bigdecimal::mul_by_u64_truncate(
+                bigdecimal::sub(bigdecimal::one(), normalized_weight),
+                amount_in
+            );
+        let fee_amount =
+            calculate_fee_with_minimum(config.swap_fee_rate, adjusted_swap_amount);
+
+        // actual amount in after deducting fee amount
+        let adjusted_amount_in = amount_in - fee_amount;
+
+        // calculate new total share and new liquidity
+        let base =
+            bigdecimal::from_ratio_u64(
+                adjusted_amount_in + pool_amount_in,
+                pool_amount_in
+            );
+        let pool_ratio = pow(base, normalized_weight);
+        let new_total_share = bigdecimal::mul_by_u128_truncate(pool_ratio, total_share);
+        ((new_total_share - total_share as u64), fee_amount, is_provide_a)
+    }
+
+    /// get all pool info at once (a_amount, b_amount, a_weight, b_weight, fee_rate)
+    public fun pool_info(
+        pair: Object<Config>, lbp_assertion: bool
+    ): (u64, u64, BigDecimal, BigDecimal, BigDecimal) acquires Config, Pool, FlashSwapLock {
+        let pair_addr = object::object_address(&pair);
+        let config = borrow_global<Config>(pair_addr);
+        if (lbp_assertion) {
+            // assert LBP start time
+            let (_, timestamp) = get_block_info();
+            assert!(
+                timestamp >= config.weights.weights_before.timestamp,
+                error::invalid_state(ELBP_NOT_STARTED)
+            );
+        };
+
+        let pool = borrow_global<Pool>(pair_addr);
+        let (coin_a_amount, coin_b_amount) = pool_amounts(pool, pair_addr);
+        let (coin_a_weight, coin_b_weight) = get_weight(&config.weights);
+
+        (
+            coin_a_amount,
+            coin_b_amount,
+            coin_a_weight,
+            coin_b_weight,
+            config.swap_fee_rate
+        )
+    }
+
+    // avoid zero fee amount to prevent fee bypass attack
+    fun calculate_fee_with_minimum(
+        swap_fee_rate: BigDecimal, amount_in: u64
+    ): u64 {
+        let fee_amount = bigdecimal::mul_by_u64_ceil(swap_fee_rate, amount_in);
+        if (fee_amount == 0) {
+            fee_amount = 1;
+        };
+
+        fee_amount
+    }
+
+    /// Calculate out amount
+    /// https://balancer.fi/whitepaper.pdf (15)
+    /// return (return_amount, fee_amount)
+    public fun swap_simulation(
+        pool_amount_in: u64,
+        pool_amount_out: u64,
+        weight_in: BigDecimal,
+        weight_out: BigDecimal,
+        amount_in: u64,
+        swap_fee_rate: BigDecimal
+    ): (u64, u64) {
+        assert!(
+            amount_in > 0,
+            error::invalid_argument(EZERO_AMOUNT_IN)
+        );
+
+        let one = bigdecimal::one();
+        let exp = bigdecimal::div(weight_in, weight_out);
+
+        let fee_amount = calculate_fee_with_minimum(swap_fee_rate, amount_in);
+        let adjusted_amount_in = amount_in - fee_amount;
+        let base =
+            bigdecimal::from_ratio_u64(
+                pool_amount_in,
+                pool_amount_in + adjusted_amount_in
+            );
+        let sub_amount = pow(base, exp);
+        (
+            bigdecimal::mul_by_u64_truncate(
+                bigdecimal::sub(one, sub_amount),
+                pool_amount_out
+            ),
+            fee_amount
+        )
+    }
+
+    public fun swap_simulation_given_out(
+        pool_amount_in: u64,
+        pool_amount_out: u64,
+        weight_in: BigDecimal,
+        weight_out: BigDecimal,
+        amount_out: u64,
+        swap_fee_rate: BigDecimal
+    ): (u64, u64) {
+        let one = bigdecimal::one();
+        let exp = bigdecimal::div(weight_out, weight_in);
+        let base = bigdecimal::from_ratio_u64(
+            pool_amount_out, pool_amount_out - amount_out
+        );
+        let base_exp = pow(base, exp);
+        let adjusted_amount_in =
+            bigdecimal::mul_by_u64(bigdecimal::sub(base_exp, one), pool_amount_in);
+        let sub_one_fee = bigdecimal::sub(one, swap_fee_rate);
+        let amount_in =
+            bigdecimal::truncate_u64(bigdecimal::div(adjusted_amount_in, sub_one_fee));
+        let fee_amount = calculate_fee_with_minimum(swap_fee_rate, amount_in);
+
+        (amount_in, fee_amount)
+    }
+
+    public fun pool_metadata(
+        pair: Object<Config>
+    ): (Object<Metadata>, Object<Metadata>) acquires Pool {
+        let pair_addr = object::object_address(&pair);
+        let pool = borrow_global<Pool>(pair_addr);
+        (
+            fungible_asset::store_metadata(pool.coin_a_store),
+            fungible_asset::store_metadata(pool.coin_b_store)
+        )
+    }
+
+    public fun pool_amounts(pool: &Pool, pair_addr: address): (u64, u64) acquires FlashSwapLock {
+        let amount_a = fungible_asset::balance(pool.coin_a_store);
+        let amount_b = fungible_asset::balance(pool.coin_b_store);
+
+        if (exists<FlashSwapLock>(pair_addr)) {
+            let flash_swap = borrow_global<FlashSwapLock>(pair_addr);
+            (
+                amount_a + flash_swap.coin_a_borrow_amount,
+                amount_b + flash_swap.coin_b_borrow_amount
+            )
+        } else {
+            (amount_a, amount_b)
+        }
+    }
+
+    /// a^x = 1 + sigma[(k^n)/n!]
+    /// k = x * ln(a)
+    fun pow(base: BigDecimal, exp: BigDecimal): BigDecimal {
+        assert!(
+            !bigdecimal::is_zero(base) && bigdecimal::lt(base, bigdecimal::from_u64(2)),
+            error::invalid_argument(EOUT_OF_BASE_RANGE)
+        );
+
+        let res = bigdecimal::one();
+        let (ln_a, neg) = ln(base);
+        let k = bigdecimal::mul(ln_a, exp);
+        let comp = k;
+        let index = 1;
+        let subs: vector<BigDecimal> = vector[];
+
+        let precision = bigdecimal::from_scaled(biguint::from_u64(PRECISION));
+        while (bigdecimal::gt(comp, precision)) {
+            if (index & 1 == 1 && neg) {
+                vector::push_back(&mut subs, comp)
+            } else {
+                res = bigdecimal::add(res, comp)
+            };
+
+            comp = bigdecimal::div_by_u64(bigdecimal::mul(comp, k), index + 1);
+            index = index + 1;
+        };
+
+        let index = 0;
+        while (index < vector::length(&subs)) {
+            let comp = vector::borrow(&subs, index);
+            res = bigdecimal::sub(res, *comp);
+            index = index + 1;
+        };
+
+        res
+    }
+
+    /// ln(1 + a) = sigma[(-1) ^ (n + 1) * (a ^ n / n)]
+    /// https://en.wikipedia.org/wiki/Taylor_series#Natural_logarithm
+    fun ln(num: BigDecimal): (BigDecimal, bool) {
+        let one = bigdecimal::one();
+        let (a, a_neg) =
+            if (bigdecimal::ge(num, one)) {
+                (bigdecimal::sub(num, one), false)
+            } else {
+                (bigdecimal::sub(one, num), true)
+            };
+
+        let res = bigdecimal::zero();
+        let comp = a;
+        let index = 1;
+
+        let precision = bigdecimal::from_scaled(biguint::from_u64(PRECISION));
+        while (bigdecimal::gt(comp, precision)) {
+            if (index & 1 == 0 && !a_neg) {
+                res = bigdecimal::sub(res, comp);
+            } else {
+                res = bigdecimal::add(res, comp);
+            };
+
+            // comp(old) = a ^ n / n
+            // comp(new) = comp(old) * a * n / (n + 1) = a ^ (n + 1) / (n + 1)
+            comp = bigdecimal::div_by_u64(
+                bigdecimal::mul_by_u64(bigdecimal::mul(comp, a), index), // comp * a * index
+                index + 1
+            );
+
+            index = index + 1;
+        };
+
+        (res, a_neg)
+    }
+
+    #[test_only]
+    public fun init_module_for_test() {
+        init_module(&initia_std::account::create_signer_for_test(@initia_std));
+    }
+
+    #[test_only]
+    use initia_std::block::set_block_info;
+
+    #[test_only]
+    struct CoinCapsInit has key {
+        burn_cap: coin::BurnCapability,
+        freeze_cap: coin::FreezeCapability,
+        mint_cap: coin::MintCapability
+    }
+
+    #[test_only]
+    struct CoinCapsUsdc has key {
+        burn_cap: coin::BurnCapability,
+        freeze_cap: coin::FreezeCapability,
+        mint_cap: coin::MintCapability
+    }
+
+    #[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 Config, CoinCapabilities, ModuleStore, Pool, FlashSwapLock {
+        init_module(&chain);
+        initia_std::primary_fungible_store::init_module_for_test();
+
+        let chain_addr = signer::address_of(&chain);
+
+        let (initia_burn_cap, initia_freeze_cap, initia_mint_cap) =
+            initialized_coin(&chain, string::utf8(b"INIT"));
+        let (usdc_burn_cap, usdc_freeze_cap, usdc_mint_cap) =
+            initialized_coin(&chain, string::utf8(b"USDC"));
+        let init_metadata = coin::metadata(chain_addr, string::utf8(b"INIT"));
+        let usdc_metadata = coin::metadata(chain_addr, string::utf8(b"USDC"));
+
+        coin::mint_to(&initia_mint_cap, chain_addr, 100000000);
+        coin::mint_to(&usdc_mint_cap, chain_addr, 100000000);
+
+        // spot price is 1
+        create_pair_script(
+            &chain,
+            std::string::utf8(b"name"),
+            std::string::utf8(b"SYMBOL"),
+            bigdecimal::from_ratio_u64(3, 1000),
+            bigdecimal::from_ratio_u64(8, 10),
+            bigdecimal::from_ratio_u64(2, 10),
+            coin::metadata(chain_addr, string::utf8(b"INIT")),
+            coin::metadata(chain_addr, string::utf8(b"USDC")),
+            80000000,
+            20000000
+        );
+
+        let lp_metadata = coin::metadata(chain_addr, string::utf8(b"SYMBOL"));
+        let pair = object::convert<Metadata, Config>(lp_metadata);
+
+        assert!(
+            coin::balance(chain_addr, init_metadata) == 20000000,
+            0
+        );
+        assert!(
+            coin::balance(chain_addr, usdc_metadata) == 80000000,
+            1
+        );
+        assert!(
+            coin::balance(chain_addr, lp_metadata) == 80000000,
+            2
+        );
+
+        // swap init to usdc
+        swap_script(
+            &chain,
+            pair,
+            init_metadata,
+            1000,
+            option::none()
+        );
+        assert!(
+            coin::balance(chain_addr, init_metadata) == 20000000 - 1000,
+            3
+        );
+        assert!(
+            coin::balance(chain_addr, usdc_metadata) == 80000000 + 996,
+            4
+        ); // return 999 commission 3
+
+        // swap usdc to init
+        swap_script(
+            &chain,
+            pair,
+            usdc_metadata,
+            1000,
+            option::none()
+        );
+        assert!(
+            coin::balance(chain_addr, init_metadata) == 20000000 - 1000 + 997,
+            5
+        ); // return 1000 commission 3
+        assert!(
+            coin::balance(chain_addr, usdc_metadata) == 80000000 + 996 - 1000,
+            6
+        );
+
+        // withdraw liquidity
+        withdraw_liquidity_script(
+            &chain,
+            pair,
+            40000000,
+            option::none(),
+            option::none()
+        );
+        assert!(
+            coin::balance(chain_addr, init_metadata) == 20000000 - 1000 + 997
+                + 40000001,
+            7
+        );
+        assert!(
+            coin::balance(chain_addr, usdc_metadata) == 80000000 + 996 - 1000
+                + 10000002,
+            8
+        );
+
+        // single asset provide liquidity (coin b)
+        // pool balance - init: 40000002, usdc: 10000002
+        single_asset_provide_liquidity_script(
+            &chain,
+            pair,
+            usdc_metadata,
+            100000,
+            option::none()
+        );
+        assert!(
+            coin::balance(chain_addr, lp_metadata) == 40000000 + 79491,
+            9
+        );
+
+        // single asset provide liquidity (coin a)
+        // pool balance - init: 40000002, usdc: 10100002
+        single_asset_provide_liquidity_script(
+            &chain,
+            pair,
+            init_metadata,
+            100000,
+            option::none()
+        );
+        assert!(
+            coin::balance(chain_addr, lp_metadata) == 40000000 + 79491 + 80090,
+            10
+        );
+
+        move_to(
+            &chain,
+            CoinCapsInit {
+                burn_cap: initia_burn_cap,
+                freeze_cap: initia_freeze_cap,
+                mint_cap: initia_mint_cap
+            }
+        );
+
+        move_to(
+            &chain,
+            CoinCapsUsdc {
+                burn_cap: usdc_burn_cap,
+                freeze_cap: usdc_freeze_cap,
+                mint_cap: usdc_mint_cap
+            }
+        );
+    }
+
+    #[test(chain = @0x1)]
+    fun lbp_end_to_end(
+        chain: signer
+    ) acquires Config, CoinCapabilities, ModuleStore, Pool, FlashSwapLock {
+        init_module(&chain);
+        initia_std::primary_fungible_store::init_module_for_test();
+
+        let chain_addr = signer::address_of(&chain);
+
+        let (initia_burn_cap, initia_freeze_cap, initia_mint_cap) =
+            initialized_coin(&chain, string::utf8(b"INIT"));
+        let (usdc_burn_cap, usdc_freeze_cap, usdc_mint_cap) =
+            initialized_coin(&chain, string::utf8(b"USDC"));
+        let init_metadata = coin::metadata(chain_addr, string::utf8(b"INIT"));
+        let usdc_metadata = coin::metadata(chain_addr, string::utf8(b"USDC"));
+
+        coin::mint_to(&initia_mint_cap, chain_addr, 100000000);
+        coin::mint_to(&usdc_mint_cap, chain_addr, 100000000);
+
+        set_block_info(10, 1000);
+
+        create_lbp_pair_script(
+            &chain,
+            std::string::utf8(b"name"),
+            std::string::utf8(b"SYMBOL"),
+            bigdecimal::from_ratio_u64(3, 1000),
+            2000,
+            bigdecimal::from_ratio_u64(99, 100),
+            bigdecimal::from_ratio_u64(1, 100),
+            3000,
+            bigdecimal::from_ratio_u64(61, 100),
+            bigdecimal::from_ratio_u64(39, 100),
+            init_metadata,
+            usdc_metadata,
+            80000000,
+            20000000
+        );
+        let lp_metadata = coin::metadata(chain_addr, string::utf8(b"SYMBOL"));
+        let pair = object::convert<Metadata, Config>(lp_metadata);
+
+        assert!(
+            get_spot_price(pair, init_metadata) == bigdecimal::from_ratio_u64(2475, 100),
+            0
+        );
+
+        // 0.8 : 0.2
+        set_block_info(11, 2500);
+        assert!(
+            get_spot_price(pair, init_metadata) == bigdecimal::one(),
+            1
+        );
+
+        // 0.61 : 0.39
+        set_block_info(12, 3500);
+        assert!(
+            get_spot_price(pair, init_metadata)
+                == bigdecimal::from_ratio_u64(391025641025641025, 1000000000000000000),
+            2
+        );
+
+        assert!(
+            coin::balance(chain_addr, init_metadata) == 20000000,
+            0
+        );
+        assert!(
+            coin::balance(chain_addr, usdc_metadata) == 80000000,
+            1
+        );
+        assert!(
+            coin::balance(chain_addr, lp_metadata) == 80000000,
+            3
+        );
+
+        // swap test during LBP (0.8: 0.2)
+        set_block_info(11, 2500);
+
+        // swap init to usdc
+        swap_script(
+            &chain,
+            pair,
+            init_metadata,
+            1000,
+            option::none()
+        );
+        assert!(
+            coin::balance(chain_addr, init_metadata) == 20000000 - 1000,
+            4
+        );
+        assert!(
+            coin::balance(chain_addr, usdc_metadata) == 80000000 + 996,
+            5
+        ); // return 999 commission 3
+
+        // swap usdc to init
+        swap_script(
+            &chain,
+            pair,
+            usdc_metadata,
+            1000,
+            option::none()
+        );
+        assert!(
+            coin::balance(chain_addr, init_metadata) == 20000000 - 1000 + 997,
+            6
+        ); // return 1000 commission 3
+        assert!(
+            coin::balance(chain_addr, usdc_metadata) == 80000000 + 996 - 1000,
+            7
+        );
+
+        move_to(
+            &chain,
+            CoinCapsInit {
+                burn_cap: initia_burn_cap,
+                freeze_cap: initia_freeze_cap,
+                mint_cap: initia_mint_cap
+            }
+        );
+
+        move_to(
+            &chain,
+            CoinCapsUsdc {
+                burn_cap: usdc_burn_cap,
+                freeze_cap: usdc_freeze_cap,
+                mint_cap: usdc_mint_cap
+            }
+        );
+    }
+
+    #[test]
+    fun get_weight_test() {
+        let weights = Weights {
+            weights_before: Weight {
+                coin_a_weight: bigdecimal::from_ratio_u64(2, 10),
+                coin_b_weight: bigdecimal::from_ratio_u64(8, 10),
+                timestamp: 1000
+            },
+            weights_after: Weight {
+                coin_a_weight: bigdecimal::from_ratio_u64(8, 10),
+                coin_b_weight: bigdecimal::from_ratio_u64(2, 10),
+                timestamp: 2000
+            }
+        };
+
+        set_block_info(10, 1000);
+        let (coin_a_weight, coin_b_weight) = get_weight(&weights);
+        assert!(
+            coin_a_weight == bigdecimal::from_ratio_u64(2, 10)
+                && coin_b_weight == bigdecimal::from_ratio_u64(8, 10),
+            0
+        );
+
+        set_block_info(15, 1500);
+        let (coin_a_weight, coin_b_weight) = get_weight(&weights);
+        assert!(
+            coin_a_weight == bigdecimal::from_ratio_u64(5, 10)
+                && coin_b_weight == bigdecimal::from_ratio_u64(5, 10),
+            1
+        );
+
+        set_block_info(20, 2000);
+        let (coin_a_weight, coin_b_weight) = get_weight(&weights);
+        assert!(
+            coin_a_weight == bigdecimal::from_ratio_u64(8, 10)
+                && coin_b_weight == bigdecimal::from_ratio_u64(2, 10),
+            2
+        );
+
+        set_block_info(30, 3000);
+        let (coin_a_weight, coin_b_weight) = get_weight(&weights);
+        assert!(
+            coin_a_weight == bigdecimal::from_ratio_u64(8, 10)
+                && coin_b_weight == bigdecimal::from_ratio_u64(2, 10),
+            3
+        );
+    }
+
+    #[test(chain = @0x1)]
+    fun get_pair_test(
+        chain: signer
+    ) acquires CoinCapabilities, Config, Pool, ModuleStore, FlashSwapLock {
+        init_module(&chain);
+        initia_std::primary_fungible_store::init_module_for_test();
+
+        let chain_addr = signer::address_of(&chain);
+
+        let (_, _, coin_a_mint_cap) = initialized_coin(&chain, string::utf8(b"A"));
+        let (_, _, coin_b_mint_cap) = initialized_coin(&chain, string::utf8(b"B"));
+        let (_, _, coin_c_mint_cap) = initialized_coin(&chain, string::utf8(b"C"));
+
+        let a_metadata = coin::metadata(chain_addr, string::utf8(b"A"));
+        let b_metadata = coin::metadata(chain_addr, string::utf8(b"B"));
+        let c_metadata = coin::metadata(chain_addr, string::utf8(b"C"));
+        let a_addr = object::object_address(&a_metadata);
+        let b_addr = object::object_address(&b_metadata);
+        let c_addr = object::object_address(&c_metadata);
+
+        coin::mint_to(&coin_a_mint_cap, chain_addr, 100000000);
+        coin::mint_to(&coin_b_mint_cap, chain_addr, 100000000);
+        coin::mint_to(&coin_c_mint_cap, chain_addr, 100000000);
+
+        create_pair_script(
+            &chain,
+            std::string::utf8(b"name"),
+            std::string::utf8(b"SYMBOL1"),
+            bigdecimal::from_ratio_u64(3, 1000),
+            bigdecimal::from_ratio_u64(5, 10),
+            bigdecimal::from_ratio_u64(5, 10),
+            a_metadata,
+            b_metadata,
+            1,
+            1
+        );
+        let lp_1_metadata = coin::metadata(chain_addr, string::utf8(b"SYMBOL1"));
+        let pair_1 = object::convert<Metadata, Config>(lp_1_metadata);
+        let pair_1_addr = object::object_address(&pair_1);
+
+        create_pair_script(
+            &chain,
+            std::string::utf8(b"name"),
+            std::string::utf8(b"SYMBOL2"),
+            bigdecimal::from_ratio_u64(3, 1000),
+            bigdecimal::from_ratio_u64(5, 10),
+            bigdecimal::from_ratio_u64(5, 10),
+            a_metadata,
+            b_metadata,
+            1,
+            1
+        );
+        let lp_2_metadata = coin::metadata(chain_addr, string::utf8(b"SYMBOL2"));
+        let pair_2 = object::convert<Metadata, Config>(lp_2_metadata);
+        let pair_2_addr = object::object_address(&pair_2);
+
+        create_pair_script(
+            &chain,
+            std::string::utf8(b"name"),
+            std::string::utf8(b"SYMBOL3"),
+            bigdecimal::from_ratio_u64(3, 1000),
+            bigdecimal::from_ratio_u64(5, 10),
+            bigdecimal::from_ratio_u64(5, 10),
+            a_metadata,
+            c_metadata,
+            1,
+            1
+        );
+        let lp_3_metadata = coin::metadata(chain_addr, string::utf8(b"SYMBOL3"));
+        let pair_3 = object::convert<Metadata, Config>(lp_3_metadata);
+        let pair_3_addr = object::object_address(&pair_3);
+
+        create_pair_script(
+            &chain,
+            std::string::utf8(b"name"),
+            std::string::utf8(b"SYMBOL4"),
+            bigdecimal::from_ratio_u64(3, 1000),
+            bigdecimal::from_ratio_u64(5, 10),
+            bigdecimal::from_ratio_u64(5, 10),
+            a_metadata,
+            c_metadata,
+            1,
+            1
+        );
+        let lp_4_metadata = coin::metadata(chain_addr, string::utf8(b"SYMBOL4"));
+        let pair_4 = object::convert<Metadata, Config>(lp_4_metadata);
+        let pair_4_addr = object::object_address(&pair_4);
+
+        let (_, timestamp) = get_block_info();
+        let weight = bigdecimal::from_ratio_u64(5, 10);
+        let swap_fee_rate = bigdecimal::from_ratio_u64(3, 1000);
+        let weights = Weights {
+            weights_before: Weight {
+                coin_a_weight: weight,
+                coin_b_weight: weight,
+                timestamp
+            },
+            weights_after: Weight {
+                coin_a_weight: weight,
+                coin_b_weight: weight,
+                timestamp
+            }
+        };
+
+        let res = get_all_pairs(
+            option::none(),
+            option::none(),
+            option::none(),
+            10
+        );
+        assert!(
+            res
+                == vector[
+                    PairResponse {
+                        coin_a: a_addr,
+                        coin_b: b_addr,
+                        liquidity_token: pair_1_addr,
+                        weights,
+                        swap_fee_rate
+                    },
+                    PairResponse {
+                        coin_a: a_addr,
+                        coin_b: b_addr,
+                        liquidity_token: pair_2_addr,
+                        weights,
+                        swap_fee_rate
+                    },
+                    PairResponse {
+                        coin_a: a_addr,
+                        coin_b: c_addr,
+                        liquidity_token: pair_3_addr,
+                        weights,
+                        swap_fee_rate
+                    },
+                    PairResponse {
+                        coin_a: a_addr,
+                        coin_b: c_addr,
+                        liquidity_token: pair_4_addr,
+                        weights,
+                        swap_fee_rate
+                    }
+                ],
+            0
+        );
+
+        let res =
+            get_all_pairs(
+                option::some(a_addr),
+                option::some(b_addr),
+                option::some(pair_1_addr),
+                10
+            );
+        assert!(
+            res
+                == vector[
+                    PairResponse {
+                        coin_a: a_addr,
+                        coin_b: b_addr,
+                        liquidity_token: pair_2_addr,
+                        weights,
+                        swap_fee_rate
+                    },
+                    PairResponse {
+                        coin_a: a_addr,
+                        coin_b: c_addr,
+                        liquidity_token: pair_3_addr,
+                        weights,
+                        swap_fee_rate
+                    },
+                    PairResponse {
+                        coin_a: a_addr,
+                        coin_b: c_addr,
+                        liquidity_token: pair_4_addr,
+                        weights,
+                        swap_fee_rate
+                    }
+                ],
+            1
+        );
+
+        let res =
+            get_all_pairs(
+                option::some(a_addr),
+                option::some(a_addr),
+                option::some(pair_1_addr),
+                10
+            );
+        assert!(
+            res
+                == vector[
+                    PairResponse {
+                        coin_a: a_addr,
+                        coin_b: b_addr,
+                        liquidity_token: pair_1_addr,
+                        weights,
+                        swap_fee_rate
+                    },
+                    PairResponse {
+                        coin_a: a_addr,
+                        coin_b: b_addr,
+                        liquidity_token: pair_2_addr,
+                        weights,
+                        swap_fee_rate
+                    },
+                    PairResponse {
+                        coin_a: a_addr,
+                        coin_b: c_addr,
+                        liquidity_token: pair_3_addr,
+                        weights,
+                        swap_fee_rate
+                    },
+                    PairResponse {
+                        coin_a: a_addr,
+                        coin_b: c_addr,
+                        liquidity_token: pair_4_addr,
+                        weights,
+                        swap_fee_rate
+                    }
+                ],
+            2
+        );
+
+        let res = get_pairs(a_addr, b_addr, option::none(), 10);
+        assert!(
+            res
+                == vector[
+                    PairResponse {
+                        coin_a: a_addr,
+                        coin_b: b_addr,
+                        liquidity_token: pair_1_addr,
+                        weights,
+                        swap_fee_rate
+                    },
+                    PairResponse {
+                        coin_a: a_addr,
+                        coin_b: b_addr,
+                        liquidity_token: pair_2_addr,
+                        weights,
+                        swap_fee_rate
+                    }
+                ],
+            3
+        );
+
+        let res = get_pairs(a_addr, b_addr, option::some(pair_1_addr), 10);
+        assert!(
+            res
+                == vector[
+                    PairResponse {
+                        coin_a: a_addr,
+                        coin_b: b_addr,
+                        liquidity_token: pair_2_addr,
+                        weights,
+                        swap_fee_rate
+                    }
+                ],
+            3
+        );
+    }
+
+    #[test_only]
+    fun test_setup(chain: &signer) acquires ModuleStore, Pool, CoinCapabilities, Config, FlashSwapLock {
+        init_module(chain);
+        initia_std::primary_fungible_store::init_module_for_test();
+
+        let chain_addr = signer::address_of(chain);
+
+        let (initia_burn_cap, initia_freeze_cap, initia_mint_cap) =
+            initialized_coin(chain, string::utf8(b"INIT"));
+        let (usdc_burn_cap, usdc_freeze_cap, usdc_mint_cap) =
+            initialized_coin(chain, string::utf8(b"USDC"));
+        let init_metadata = coin::metadata(chain_addr, string::utf8(b"INIT"));
+        let usdc_metadata = coin::metadata(chain_addr, string::utf8(b"USDC"));
+
+        coin::mint_to(&initia_mint_cap, chain_addr, 100000000);
+        coin::mint_to(&usdc_mint_cap, chain_addr, 100000000);
+
+        // spot price is 1
+        create_pair_script(
+            chain,
+            std::string::utf8(b"name"),
+            std::string::utf8(b"SYMBOL"),
+            bigdecimal::from_ratio_u64(3, 1000),
+            bigdecimal::from_ratio_u64(8, 10),
+            bigdecimal::from_ratio_u64(2, 10),
+            coin::metadata(chain_addr, string::utf8(b"INIT")),
+            coin::metadata(chain_addr, string::utf8(b"USDC")),
+            80000000,
+            20000000
+        );
+
+        assert!(
+            coin::balance(chain_addr, init_metadata) == 20000000,
+            0
+        );
+        assert!(
+            coin::balance(chain_addr, usdc_metadata) == 80000000,
+            1
+        );
+
+        let lp_metadata = coin::metadata(chain_addr, string::utf8(b"SYMBOL"));
+        assert!(
+            coin::balance(chain_addr, lp_metadata) == 80000000,
+            2
+        );
+
+        move_to(
+            chain,
+            CoinCapsInit {
+                burn_cap: initia_burn_cap,
+                freeze_cap: initia_freeze_cap,
+                mint_cap: initia_mint_cap
+            }
+        );
+
+        move_to(
+            chain,
+            CoinCapsUsdc {
+                burn_cap: usdc_burn_cap,
+                freeze_cap: usdc_freeze_cap,
+                mint_cap: usdc_mint_cap
+            }
+        );
+    }
+
+    struct TestMetadata has drop {
+        lp_metadata: Object<Metadata>,
+        offer_metadata: Object<Metadata>,
+        return_metadata: Object<Metadata>
+    }
+
+    #[test_only]
+    fun test_setup_flash_swap(
+        chain: &signer,
+        borrower: &signer,
+        borrow_amount: u64,
+        mint_amount: u64
+    ): (TestMetadata, FungibleAsset, FungibleAsset, FlashSwapReceipt) acquires ModuleStore, Pool, CoinCapabilities, Config, FlashSwapLock, CoinCapsInit {
+        test_setup(chain);
+
+        let chain_addr = signer::address_of(chain);
+        let borrower_addr = signer::address_of(borrower);
+
+        let init_metadata = coin::metadata(chain_addr, string::utf8(b"INIT"));
+        let usdc_metadata = coin::metadata(chain_addr, string::utf8(b"USDC"));
+        let lp_metadata = coin::metadata(chain_addr, string::utf8(b"SYMBOL"));
+        let pair = object::convert<Metadata, Config>(lp_metadata);
+
+        coin::mint_to(
+            &borrow_global<CoinCapsInit>(chain_addr).mint_cap,
+            borrower_addr,
+            mint_amount
+        );
+        let offer_fa = coin::withdraw(borrower, init_metadata, mint_amount);
+        // flash_swap init to usdc
+        let (return_fa, receipt) =
+            flash_swap(
+                pair,
+                init_metadata,
+                borrow_amount,
+                option::none()
+            );
+
+        (
+            TestMetadata {
+                lp_metadata,
+                offer_metadata: init_metadata,
+                return_metadata: usdc_metadata
+            },
+            offer_fa,
+            return_fa,
+            receipt
+        )
+    }
+
+    #[test(chain = @0x1, borrower = @0x1782)]
+    fun test_dex_flash_swap(
+        chain: &signer, borrower: &signer
+    ) acquires ModuleStore, Pool, CoinCapabilities, Config, FlashSwapLock, CoinCapsInit {
+        let (test_metadata, offer_fa, return_fa, receipt) =
+            test_setup_flash_swap(chain, borrower, 1000, 1000);
+        let borrower_addr = signer::address_of(borrower);
+        coin::deposit(borrower_addr, return_fa);
+
+        repay_flash_swap(offer_fa, receipt);
+        assert!(
+            !exists<FlashSwapLock>(object::object_address(&test_metadata.lp_metadata)),
+            5
+        );
+    }
+
+    #[test(chain = @0x1, borrower = @0x1782)]
+    #[expected_failure(abort_code = 0x10017, location = Self)]
+    fun test_dex_flash_swap_not_enough_repayment(
+        chain: &signer, borrower: &signer
+    ) acquires ModuleStore, Pool, CoinCapabilities, Config, FlashSwapLock, CoinCapsInit {
+        let (_, offer_fa, return_fa, receipt) =
+            test_setup_flash_swap(chain, borrower, 1000, 999);
+        let borrower_addr = signer::address_of(borrower);
+        coin::deposit(borrower_addr, return_fa);
+
+        repay_flash_swap(offer_fa, receipt);
+    }
+
+    #[test(chain = @0x1, borrower = @0x1782)]
+    #[expected_failure(abort_code = 0x10017, location = Self)]
+    fun test_dex_flash_swap_extra_repayment(
+        chain: &signer, borrower: &signer
+    ) acquires ModuleStore, Pool, CoinCapabilities, Config, FlashSwapLock, CoinCapsInit {
+        let (_, offer_fa, return_fa, receipt) =
+            test_setup_flash_swap(chain, borrower, 1000, 1001);
+        let borrower_addr = signer::address_of(borrower);
+        coin::deposit(borrower_addr, return_fa);
+
+        repay_flash_swap(offer_fa, receipt);
+    }
+
+    #[test(chain = @0x1, borrower = @0x1782)]
+    #[expected_failure(abort_code = 0x30016, location = Self)]
+    fun test_dex_flash_swap_recursive(
+        chain: &signer, borrower: &signer
+    ) acquires ModuleStore, Pool, CoinCapabilities, Config, FlashSwapLock, CoinCapsInit {
+        let (test_metadata, offer_fa, return_fa, receipt) =
+            test_setup_flash_swap(chain, borrower, 1000, 1000);
+        let borrower_addr = signer::address_of(borrower);
+        coin::deposit(borrower_addr, offer_fa);
+        coin::deposit(borrower_addr, return_fa);
+        let FlashSwapReceipt { pair_addr: _ } = receipt;
+
+        // recursive flash_swap
+        let pair = object::convert<Metadata, Config>(test_metadata.lp_metadata);
+        let (return_fa, receipt) =
+            flash_swap(
+                pair,
+                test_metadata.offer_metadata,
+                1000,
+                option::none()
+            );
+        coin::deposit(borrower_addr, return_fa);
+        let FlashSwapReceipt { pair_addr: _ } = receipt;
+    }
+
+    #[test(chain = @0x1, borrower = @0x1782)]
+    #[expected_failure(abort_code = 0x30016, location = Self)]
+    fun test_dex_flash_swap_block_swap(
+        chain: &signer, borrower: &signer
+    ) acquires ModuleStore, Pool, CoinCapabilities, Config, FlashSwapLock, CoinCapsInit {
+        let (test_metadata, offer_fa, return_fa, receipt) =
+            test_setup_flash_swap(chain, borrower, 1000, 1000);
+        let borrower_addr = signer::address_of(borrower);
+        coin::deposit(borrower_addr, return_fa);
+        let FlashSwapReceipt { pair_addr: _ } = receipt;
+
+        // execute swap
+        let pair = object::convert<Metadata, Config>(test_metadata.lp_metadata);
+        let return_fa = swap(pair, offer_fa);
+        coin::deposit(borrower_addr, return_fa);
+    }
+
+    #[test(chain = @0x1, borrower = @0x1782)]
+    #[expected_failure(abort_code = 0x30016, location = Self)]
+    fun test_dex_flash_swap_block_provide_liquidity(
+        chain: &signer, borrower: &signer
+    ) acquires ModuleStore, Pool, CoinCapabilities, Config, FlashSwapLock, CoinCapsInit {
+        let (test_metadata, offer_fa, return_fa, receipt) =
+            test_setup_flash_swap(chain, borrower, 1000, 1000);
+        let borrower_addr = signer::address_of(borrower);
+        let FlashSwapReceipt { pair_addr: _ } = receipt;
+
+        // execute provide_liquidity
+        let pair = object::convert<Metadata, Config>(test_metadata.lp_metadata);
+        let lp_fa = provide_liquidity(pair, offer_fa, return_fa, option::none());
+
+        coin::deposit(borrower_addr, lp_fa);
+    }
+
+    #[test(chain = @0x1, borrower = @0x1782)]
+    #[expected_failure(abort_code = 0x30016, location = Self)]
+    fun test_dex_flash_swap_block_single_asset_provide_liquidity(
+        chain: &signer, borrower: &signer
+    ) acquires ModuleStore, Pool, CoinCapabilities, Config, FlashSwapLock, CoinCapsInit {
+        let (test_metadata, offer_fa, return_fa, receipt) =
+            test_setup_flash_swap(chain, borrower, 1000, 1000);
+        let borrower_addr = signer::address_of(borrower);
+        coin::deposit(borrower_addr, return_fa);
+        let FlashSwapReceipt { pair_addr: _ } = receipt;
+
+        // execute provide_liquidity
+        let pair = object::convert<Metadata, Config>(test_metadata.lp_metadata);
+        let lp_fa = single_asset_provide_liquidity(pair, offer_fa, option::none());
+
+        coin::deposit(borrower_addr, lp_fa);
+    }
+
+    #[test(chain = @0x1, borrower = @0x1782)]
+    #[expected_failure(abort_code = 0x30016, location = Self)]
+    fun test_dex_flash_swap_block_withdraw_liquidity(
+        chain: &signer, borrower: &signer
+    ) acquires ModuleStore, Pool, CoinCapabilities, Config, FlashSwapLock, CoinCapsInit {
+        let (test_metadata, offer_fa, return_fa, receipt) =
+            test_setup_flash_swap(chain, borrower, 1000, 1000);
+        let borrower_addr = signer::address_of(borrower);
+        coin::deposit(borrower_addr, offer_fa);
+        coin::deposit(borrower_addr, return_fa);
+        let FlashSwapReceipt { pair_addr: _ } = receipt;
+
+        // execute provide_liquidity
+        let lp_fa = coin::withdraw(chain, test_metadata.lp_metadata, 1);
+        let (a_fa, b_fa) = withdraw_liquidity(lp_fa, option::none(), option::none());
+
+        coin::deposit(borrower_addr, a_fa);
+        coin::deposit(borrower_addr, b_fa);
+    }
+}