create-dubhe 0.0.8 → 0.0.9

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

@@ -0,0 +1,3461 @@
+module initia_std::minitswap {
+    use std::signer;
+    use std::error;
+    use std::event;
+    use std::option::{Self, Option};
+    use std::hash::{sha2_256, sha3_256};
+    use std::vector;
+
+    use initia_std::address::to_sdk;
+    use initia_std::base64;
+    use initia_std::bcs;
+    use initia_std::block;
+    use initia_std::cosmos;
+    use initia_std::bigdecimal::{Self, BigDecimal};
+    use initia_std::table::{Self, Table};
+    use initia_std::table_key;
+    use initia_std::object::{Self, ExtendRef, Object};
+    use initia_std::stableswap::{Self, Pool};
+    use initia_std::string::{Self, String};
+    use initia_std::fungible_asset::{Self, FungibleAsset, Metadata};
+    use initia_std::primary_fungible_store;
+    use initia_std::coin;
+    use initia_std::json;
+    use initia_std::string_utils::to_string;
+    use initia_std::hex;
+
+    // Errors
+    const EUNAUTHORIZED: u64 = 1;
+    const EPOOL_NOT_FOUND: u64 = 2;
+    const ENOT_INIT: u64 = 3;
+    const ENOT_ENOUGH_BALANCE: u64 = 4;
+    const EINACTIVE: u64 = 5;
+    const ENOT_SHARE_TOKEN: u64 = 6;
+    const EIBC_OP_INIT_PRICE_TOO_LOW: u64 = 7;
+    const EMAX_CHANGE: u64 = 8;
+    const EMIN_RETURN: u64 = 9;
+    const EPOOL_SIZE: u64 = 10;
+    const EVM_TYPE: u64 = 12;
+    const EAMOUNT_MISMATCH: u64 = 13;
+    const EEMERGENCY: u64 = 14;
+    const ERELEASE_TIME: u64 = 15;
+    const EINVAILD_METADATA: u64 = 16;
+    const ESMALL_ARB_PROFIT: u64 = 17;
+    const EVIRTUAL_POOL_EXISTS: u64 = 18;
+
+    const A_PRECISION: u256 = 100;
+    const U64_MAX: u128 = 18_446_744_073_709_551_615;
+    const SYMBOL: vector<u8> = b"uoinit";
+
+    // VM types
+    const MOVE: u8 = 0;
+    const COSMWASM: u8 = 1;
+    const EVM: u8 = 2;
+
+    const MAX_LIMIT: u64 = 30;
+
+    struct ModuleStore has key {
+        /// Extend reference
+        extend_ref: ExtendRef,
+        /// List of pools
+        pools: Table<Object<Metadata>, Pools>,
+        /// Max pool size change rate
+        max_change_rate: BigDecimal,
+        /// If this state is True, every depositor related transaction sent to Minitswap will fail
+        emergency_state: bool,
+        /// admin address who can change emergency_state and pool active
+        admin: address,
+
+        // deposit unbond related
+
+        /// Not real balance, the amount for shares
+        depositor_owned_init: u64,
+        /// unbond period
+        unbond_period: u64,
+        /// unbond wait list. key: address + release time
+        unbond_wait_list: Table<vector<u8>, UnbondEntity>,
+        /// mint capability of liquidity token
+        mint_cap: coin::MintCapability,
+        /// burn capability of liquidity token
+        burn_cap: coin::BurnCapability,
+
+        // stable swap configs
+
+        /// ANN
+        stableswap_ann: u64,
+        /// swap fee rate
+        stableswap_swap_fee_rate: BigDecimal,
+
+        // swap related configs
+
+        /// Swap fee rate
+        swap_fee_rate: BigDecimal,
+        /// Swap fee rate
+        arb_fee_rate: BigDecimal,
+
+        // in house arb configs
+
+        /// The amount of uinit that the user will take during finalization of in-house arb
+        trigger_fee: u64,
+        /// The minimum time needed to trigger the arbitrage
+        min_arb_profit: u64,
+        /// How much minimum pegkeeper ibc_op_init balance is needed to trigger the arb
+        ibc_timeout: u64,
+        /// Maximum arb_batch size
+        max_arb_batch: u64,
+        /// Minimum arb interval
+        min_arb_interval: u64,
+        /// global arb map. index => Virtual Pool
+        global_arb_batch_map: Table<vector<u8>, Object<VirtualPool>>,
+        /// arb batc index
+        arb_batch_index: u64
+    }
+
+    struct VirtualPool has key {
+        /// IBC OP init metadata
+        ibc_op_init_metadata: Object<Metadata>,
+        /// Extend reference
+        extend_ref: ExtendRef,
+        /// Z. Virtual pool size
+        pool_size: u64,
+        /// V. Recover velocity. Real recover amount = Vt
+        recover_velocity: BigDecimal,
+        /// R_max max recover ratio
+        max_ratio: BigDecimal,
+        /// f. Flexibility
+        recover_param: BigDecimal,
+        /// Virtual pool amount of INIT
+        init_pool_amount: u64,
+        /// Virtual pool amount of ibc_op_INIT
+        ibc_op_init_pool_amount: u64,
+        /// last recovered timestamp
+        last_recovered_timestamp: u64,
+        /// INIT balance of peg keeper (negative value)
+        virtual_init_balance: u64,
+        /// ibc op INIT balance of peg keeper
+        virtual_ibc_op_init_balance: u64,
+        /// ibc op INIT balance of peg keeper which also include unprocessed arb_batch state.
+        peg_keeper_owned_ibc_op_init_balance: u64,
+        /// ANN
+        ann: u64,
+        /// Is pool in active
+        active: bool,
+
+        // in house arb configs
+
+        /// op bridge id
+        op_bridge_id: u64,
+        /// ibc channel
+        ibc_channel: String,
+        /// layer 2 vm type. One of MOVE or COSMWASM
+        vm_type: u8,
+        /// hook contract
+        hook_contract: String,
+        /// ongoing in house arb info
+        arb_batch_map: Table<vector<u8>, ArbInfo>
+    }
+
+    struct Pools has store {
+        op_bridge_id: u64,
+        ibc_channel: String,
+        virtual_pool: Option<Object<VirtualPool>>,
+        stableswap_pool: Option<Object<Pool>>
+    }
+
+    struct UnbondEntity has store {
+        // owner of unbond entity
+        account: address,
+        // share amount that burnt
+        share_amount: u64,
+        // init withdraw amount
+        withdraw_amount: u64,
+        // release timestamp
+        release_time: u64
+    }
+
+    struct ArbInfo has store {
+        // executed timestamp
+        executed_time: u64,
+        // init amount that peg keeper swapped
+        init_used: u64,
+        // amount of ibc op init sent
+        ibc_op_init_sent: u64,
+        // triggering fee
+        triggering_fee: u64
+    }
+
+    #[event]
+    /// Event emitted when virtual pool created
+    struct CreatePoolEvent has drop, store {
+        ibc_op_init_metadata: Object<Metadata>,
+        recover_velocity: BigDecimal,
+        pool_size: u64,
+        ann: u64,
+        max_ratio: BigDecimal,
+        recover_param: BigDecimal
+    }
+
+    #[event]
+    /// Event emitted when virtual pool size changed
+    struct ChangePoolSizeEvent has drop, store {
+        ibc_op_init_metadata: Object<Metadata>,
+        pool_size: u64,
+        depositor_owned_init_increase: u64
+    }
+
+    #[event]
+    /// Event emitted when update param of virtual pool
+    struct UpdatePoolParamsEvent has drop, store {
+        ibc_op_init_metadata: Object<Metadata>,
+        recover_velocity: Option<BigDecimal>,
+        ann: Option<u64>,
+        max_ratio: Option<BigDecimal>,
+        recover_param: Option<BigDecimal>,
+        hook_contract: Option<String>
+    }
+
+    #[event]
+    /// Event emitted when provide.
+    struct ProvideEvent has drop, store {
+        provide_amount: u64,
+        share_amount: u64
+    }
+
+    #[event]
+    /// Event emitted when unbond.
+    struct UnbondEvent has drop, store {
+        account: address,
+        share_amount: u64,
+        withdraw_amount: u64,
+        release_time: u64
+    }
+
+    #[event]
+    /// Event emitted when withdraw unbond.
+    struct WithdrawUnbondEvent has drop, store {
+        account: address,
+        share_amount: u64,
+        withdraw_amount: u64,
+        release_time: u64
+    }
+
+    #[event]
+    /// Event emitted when swap token.
+    struct SwapEvent has drop, store {
+        offer_coin: Object<Metadata>,
+        return_coin: Object<Metadata>,
+        peg_keeper_offer_amount: u64, // always init
+        peg_keeper_return_amount: u64, // always ibc op init
+        offer_amount: u64,
+        return_amount: u64,
+        init_swap_fee_amount: u64,
+        init_arb_fee_amount: u64,
+        ibc_op_init_swap_fee_amount: u64,
+        ibc_op_init_arb_fee_amount: u64
+    }
+
+    #[event]
+    /// Event emitted when stable swap pool created
+    struct CreateStableswapPoolEvent has drop, store {
+        ibc_op_init_metadata: Object<Metadata>,
+        pool: Object<Pool>
+    }
+
+    #[event]
+    /// Event emitted when arb initiated
+    struct InitiateArbEvent has drop, store {
+        arb_index: u64,
+        pool: Object<VirtualPool>,
+        executed_time: u64,
+        init_used: u64,
+        ibc_op_init_sent: u64,
+        triggering_fee: u64
+    }
+
+    #[event]
+    /// Event emitted when arb finalized
+    struct FinalizeArbEvent has drop, store {
+        arb_index: u64,
+        pool: Object<VirtualPool>,
+        init_used: u64,
+        ibc_op_init_sent: u64,
+        triggering_fee: u64
+    }
+
+    #[event]
+    /// Event emitted when arb reverted
+    struct RevertArbEvent has drop, store {
+        arb_index: u64,
+        pool: Object<VirtualPool>,
+        init_used: u64,
+        ibc_op_init_sent: u64,
+        triggering_fee: u64
+    }
+
+    fun init_module(chain: &signer) {
+        let constructor_ref = object::create_object(@initia_std, false);
+        let extend_ref = object::generate_extend_ref(&constructor_ref);
+
+        let (mint_cap, burn_cap, _) =
+            coin::initialize(
+                chain,
+                option::some(U64_MAX),
+                string::utf8(b"minitswap liquidity token"),
+                string::utf8(SYMBOL),
+                6,
+                string::utf8(b""),
+                string::utf8(b"")
+            );
+
+        move_to(
+            chain,
+            ModuleStore {
+                extend_ref,
+                pools: table::new(),
+                max_change_rate: bigdecimal::from_ratio_u64(1, 10), // 10%
+                emergency_state: false,
+                admin: @initia_std,
+                depositor_owned_init: 0,
+                unbond_period: 60 * 60 * 24 * 7, // 7days
+                unbond_wait_list: table::new(),
+                mint_cap,
+                burn_cap,
+                stableswap_ann: 3000,
+                stableswap_swap_fee_rate: bigdecimal::from_ratio_u64(1, 1000), // 0.1%
+                swap_fee_rate: bigdecimal::from_ratio_u64(1, 1000), // 0.1%
+                arb_fee_rate: bigdecimal::from_ratio_u64(1, 1000), // 0.1% TODO: set initial value
+                trigger_fee: 50000, // 0.5 init TODO: set initial value
+                min_arb_profit: 1000000, // 1 init TODO: set initial value
+                ibc_timeout: 60 * 10, // 10 mins
+                max_arb_batch: 20,
+                min_arb_interval: 60 * 60 * 24, // 1 day TODO: set initial value
+                global_arb_batch_map: table::new(),
+                arb_batch_index: 0
+            }
+        );
+    }
+
+    //
+    // View Functions
+    //
+
+    #[view]
+    public fun get_pool_amount(
+        ibc_op_init_metadata: Object<Metadata>, after_peg_keeper_swap: bool
+    ): (u64, u64) acquires ModuleStore, VirtualPool {
+        let virtual_pool_exists = virtual_pool_exists(ibc_op_init_metadata);
+
+        assert!(
+            virtual_pool_exists,
+            error::invalid_argument(EPOOL_NOT_FOUND)
+        );
+
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        let pools = table::borrow(&mut module_store.pools, ibc_op_init_metadata);
+        let pool =
+            borrow_global_mut<VirtualPool>(
+                object::object_address(&*option::borrow(&pools.virtual_pool))
+            );
+        assert!(pool.active, error::invalid_state(EINACTIVE));
+        let (swap_amount, return_amount) =
+            if (after_peg_keeper_swap) {
+                calc_peg_keeper_swap(pool)
+            } else { (0, 0) };
+        return (
+            pool.init_pool_amount + swap_amount,
+            pool.ibc_op_init_pool_amount - return_amount
+        )
+    }
+
+    #[view]
+    public fun get_pool_amount_by_denom(
+        ibc_op_init_denom: String, after_peg_keeper_swap: bool
+    ): (u64, u64) acquires ModuleStore, VirtualPool {
+        let ibc_op_init_metadata = coin::denom_to_metadata(ibc_op_init_denom);
+        get_pool_amount(ibc_op_init_metadata, after_peg_keeper_swap)
+    }
+
+    #[view]
+    public fun get_peg_keeper_balance(
+        ibc_op_init_metadata: Object<Metadata>, after_peg_keeper_swap: bool
+    ): (u64, u64) acquires ModuleStore, VirtualPool {
+        let (_, pool) = borrow_all(ibc_op_init_metadata);
+        assert!(pool.active, error::invalid_state(EINACTIVE));
+        let (swap_amount, return_amount) =
+            if (after_peg_keeper_swap) {
+                calc_peg_keeper_swap(pool)
+            } else { (0, 0) };
+
+        return (
+            pool.virtual_init_balance + swap_amount,
+            pool.virtual_ibc_op_init_balance + return_amount
+        )
+    }
+
+    #[view]
+    public fun get_peg_keeper_balance_by_denom(
+        ibc_op_init_denom: String, after_peg_keeper_swap: bool
+    ): (u64, u64) acquires ModuleStore, VirtualPool {
+        let ibc_op_init_metadata = coin::denom_to_metadata(ibc_op_init_denom);
+        get_peg_keeper_balance(ibc_op_init_metadata, after_peg_keeper_swap)
+    }
+
+    #[view]
+    public fun swap_simulation(
+        offer_metadata: Object<Metadata>,
+        return_metadata: Object<Metadata>,
+        offer_amount: u64
+    ): (u64, u64) acquires ModuleStore, VirtualPool {
+        let (return_amount, fee_amount) =
+            safe_swap_simulation(offer_metadata, return_metadata, offer_amount);
+        assert!(
+            return_amount != 0,
+            error::invalid_state(EIBC_OP_INIT_PRICE_TOO_LOW)
+        );
+        (return_amount, fee_amount)
+    }
+
+    #[view]
+    public fun swap_simulation_given_out(
+        offer_metadata: Object<Metadata>,
+        return_metadata: Object<Metadata>,
+        return_amount: u64
+    ): (u64, u64) acquires ModuleStore, VirtualPool {
+        let (return_amount, fee_amount) =
+            safe_swap_simulation_given_out(
+                offer_metadata,
+                return_metadata,
+                return_amount
+            );
+        assert!(
+            return_amount != (U64_MAX as u64),
+            error::invalid_state(EIBC_OP_INIT_PRICE_TOO_LOW)
+        );
+        (return_amount, fee_amount)
+    }
+
+    #[view]
+    public fun swap_simulation_by_denom(
+        offer_denom: String, return_denom: String, offer_amount: u64
+    ): (u64, u64) acquires ModuleStore, VirtualPool {
+        let offer_metadata = coin::denom_to_metadata(offer_denom);
+        let return_metadata = coin::denom_to_metadata(return_denom);
+        swap_simulation(offer_metadata, return_metadata, offer_amount)
+    }
+
+    #[view]
+    public fun spot_price(
+        base_metadata: Object<Metadata>, quote_metadata: Object<Metadata>
+    ): BigDecimal acquires ModuleStore, VirtualPool {
+        let is_init_quote = is_init_metadata(quote_metadata);
+        let ibc_op_init_metadata = if (is_init_quote) {
+            base_metadata
+        } else {
+            quote_metadata
+        };
+
+        let virtual_pool_exists = virtual_pool_exists(ibc_op_init_metadata);
+
+        assert!(
+            virtual_pool_exists,
+            error::invalid_argument(EPOOL_NOT_FOUND)
+        );
+
+        let (init_pool_amount, ibc_op_init_pool_amount) =
+            get_pool_amount(ibc_op_init_metadata, !is_init_quote);
+        let (_, pool) = borrow_all(ibc_op_init_metadata);
+
+        let swap_amount = 1000000;
+        let ibc_op_init_return_amount =
+            get_return_amount(
+                swap_amount,
+                init_pool_amount,
+                ibc_op_init_pool_amount,
+                pool.pool_size,
+                pool.ann
+            );
+        let init_return_amount =
+            get_return_amount(
+                swap_amount,
+                ibc_op_init_pool_amount,
+                init_pool_amount,
+                pool.pool_size,
+                pool.ann
+            );
+
+        if (is_init_quote) {
+            bigdecimal::from_ratio_u64(
+                init_return_amount + swap_amount,
+                ibc_op_init_return_amount + swap_amount
+            )
+        } else {
+            bigdecimal::from_ratio_u64(
+                ibc_op_init_return_amount + swap_amount,
+                init_return_amount + swap_amount
+            )
+        }
+    }
+
+    #[view]
+    public fun get_unbond_list(
+        account: address, start_after: Option<u64>, limit: u64
+    ): vector<UnbondResponse> acquires ModuleStore {
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+        let start_key =
+            if (option::is_some(&start_after)) {
+                generate_unbond_key(account, *option::borrow(&start_after) + 1)
+            } else {
+                generate_unbond_key(account, 0)
+            };
+
+        if (limit > MAX_LIMIT) {
+            limit = MAX_LIMIT
+        };
+
+        let iter =
+            table::iter(
+                &module_store.unbond_wait_list,
+                option::some(start_key),
+                option::none(),
+                1
+            );
+
+        let i = 0;
+        let res: vector<UnbondResponse> = vector[];
+        while (i < limit && table::prepare(iter)) {
+            let (_, value) = table::next<vector<u8>, UnbondEntity>(iter);
+            if (value.account != account) break;
+
+            vector::push_back(
+                &mut res,
+                UnbondResponse {
+                    account: value.account,
+                    share_amount: value.share_amount,
+                    withdraw_amount: value.withdraw_amount,
+                    release_time: value.release_time
+                }
+            );
+        };
+
+        return res
+    }
+
+    #[view]
+    public fun get_arb_info(id: u64): ArbResponse acquires ModuleStore, VirtualPool {
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+        let pool_obj =
+            table::borrow(
+                &module_store.global_arb_batch_map,
+                table_key::encode_u64(id)
+            );
+        let pool = borrow_global<VirtualPool>(object::object_address(&*pool_obj));
+        let arb_info = table::borrow(
+            &pool.arb_batch_map,
+            table_key::encode_u64(id)
+        );
+
+        return ArbResponse {
+            ibc_op_init_metadata: pool.ibc_op_init_metadata,
+            id,
+            executed_time: arb_info.executed_time,
+            init_used: arb_info.init_used,
+            ibc_op_init_sent: arb_info.ibc_op_init_sent,
+            triggering_fee: arb_info.triggering_fee
+        }
+    }
+
+    #[view]
+    public fun get_arb_infos(
+        ibc_op_init_metadata: Object<Metadata>, start_after: Option<u64>, limit: u64
+    ): vector<ArbResponse> acquires ModuleStore, VirtualPool {
+        let (_, pool) = borrow_all(ibc_op_init_metadata);
+        let start_key =
+            if (option::is_some(&start_after)) {
+                table_key::encode_u64(*option::borrow(&start_after) + 1)
+            } else {
+                table_key::encode_u64(0)
+            };
+
+        if (limit > MAX_LIMIT) {
+            limit = MAX_LIMIT
+        };
+
+        let iter =
+            table::iter(
+                &pool.arb_batch_map,
+                option::some(start_key),
+                option::none(),
+                1
+            );
+
+        let i = 0;
+        let res: vector<ArbResponse> = vector[];
+        while (i < limit && table::prepare(iter)) {
+            let (key, arb_info) = table::next<vector<u8>, ArbInfo>(iter);
+            let id = table_key::decode_u64(key);
+
+            vector::push_back(
+                &mut res,
+                ArbResponse {
+                    ibc_op_init_metadata: pool.ibc_op_init_metadata,
+                    id,
+                    executed_time: arb_info.executed_time,
+                    init_used: arb_info.init_used,
+                    ibc_op_init_sent: arb_info.ibc_op_init_sent,
+                    triggering_fee: arb_info.triggering_fee
+                }
+            );
+        };
+
+        return res
+    }
+
+    #[view]
+    public fun get_module_store(): ModuleStoreResponse acquires ModuleStore {
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+
+        return ModuleStoreResponse {
+            max_change_rate: module_store.max_change_rate,
+            emergency_state: module_store.emergency_state,
+            admin: module_store.admin,
+            depositor_owned_init: module_store.depositor_owned_init,
+            unbond_period: module_store.unbond_period,
+            swap_fee_rate: module_store.swap_fee_rate,
+            arb_fee_rate: module_store.arb_fee_rate,
+            trigger_fee: module_store.trigger_fee,
+            min_arb_profit: module_store.min_arb_profit,
+            ibc_timeout: module_store.ibc_timeout,
+            max_arb_batch: module_store.max_arb_batch,
+            min_arb_interval: module_store.min_arb_interval,
+            arb_batch_index: module_store.arb_batch_index
+        }
+    }
+
+    #[view]
+    public fun get_pools(ibc_op_init_metadata: Object<Metadata>): PoolsResponse acquires ModuleStore {
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+        let pools = table::borrow(&module_store.pools, ibc_op_init_metadata);
+        return PoolsResponse {
+            ibc_op_init_metadata,
+            ibc_op_init_denom: coin::symbol(ibc_op_init_metadata),
+            op_bridge_id: pools.op_bridge_id,
+            ibc_channel: pools.ibc_channel,
+            virtual_pool: pools.virtual_pool,
+            stableswap_pool: pools.stableswap_pool
+        }
+    }
+
+    #[view]
+    public fun get_pools_list(
+        start_after: Option<Object<Metadata>>, limit: u64
+    ): vector<PoolsResponse> acquires ModuleStore {
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+
+        if (limit > MAX_LIMIT) {
+            limit = MAX_LIMIT
+        };
+
+        let iter = table::iter(
+            &module_store.pools,
+            option::none(),
+            start_after,
+            2
+        );
+
+        let i = 0;
+        let res: vector<PoolsResponse> = vector[];
+        while (i < limit && table::prepare(iter)) {
+            let (ibc_op_init_metadata, pools) = table::next<Object<Metadata>, Pools>(iter);
+
+            vector::push_back(
+                &mut res,
+                PoolsResponse {
+                    ibc_op_init_metadata,
+                    ibc_op_init_denom: coin::symbol(ibc_op_init_metadata),
+                    op_bridge_id: pools.op_bridge_id,
+                    ibc_channel: pools.ibc_channel,
+                    virtual_pool: pools.virtual_pool,
+                    stableswap_pool: pools.stableswap_pool
+                }
+            );
+        };
+
+        return res
+    }
+
+    #[view]
+    public fun get_pools_detail(
+        ibc_op_init_metadata: Object<Metadata>
+    ): PoolsDetailResponse acquires ModuleStore, VirtualPool {
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+        let pools = table::borrow(&module_store.pools, ibc_op_init_metadata);
+        let virtual_pool =
+            if (option::is_some(&pools.virtual_pool)) {
+                let vp =
+                    borrow_global<VirtualPool>(
+                        object::object_address(&*option::borrow(&pools.virtual_pool))
+                    );
+                option::some(
+                    VirtualPoolDetail {
+                        pool_size: vp.pool_size,
+                        recover_velocity: vp.recover_velocity,
+                        max_ratio: vp.max_ratio,
+                        recover_param: vp.recover_param,
+                        init_pool_amount: vp.init_pool_amount,
+                        ibc_op_init_pool_amount: vp.ibc_op_init_pool_amount,
+                        last_recovered_timestamp: vp.last_recovered_timestamp,
+                        virtual_init_balance: vp.virtual_init_balance,
+                        virtual_ibc_op_init_balance: vp.virtual_ibc_op_init_balance,
+                        peg_keeper_owned_ibc_op_init_balance: vp.peg_keeper_owned_ibc_op_init_balance,
+                        ann: vp.ann,
+                        active: vp.active
+                    }
+                )
+            } else {
+                option::none()
+            };
+
+        let stableswap_pool =
+            if (option::is_some(&pools.stableswap_pool)) {
+                option::some(
+                    stableswap::get_pool(*option::borrow(&pools.stableswap_pool))
+                )
+            } else {
+                option::none()
+            };
+
+        return PoolsDetailResponse {
+            ibc_op_init_metadata,
+            ibc_op_init_denom: coin::symbol(ibc_op_init_metadata),
+            op_bridge_id: pools.op_bridge_id,
+            ibc_channel: pools.ibc_channel,
+            virtual_pool: virtual_pool,
+            stableswap_pool
+        }
+    }
+
+    #[view]
+    public fun get_pools_detail_list(
+        start_after: Option<Object<Metadata>>, limit: u64
+    ): vector<PoolsDetailResponse> acquires ModuleStore, VirtualPool {
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+
+        if (limit > MAX_LIMIT) {
+            limit = MAX_LIMIT
+        };
+
+        let iter = table::iter(
+            &module_store.pools,
+            option::none(),
+            start_after,
+            2
+        );
+
+        let i = 0;
+        let res: vector<PoolsDetailResponse> = vector[];
+        while (i < limit && table::prepare(iter)) {
+            let (ibc_op_init_metadata, pools) = table::next<Object<Metadata>, Pools>(iter);
+
+            let virtual_pool =
+                if (option::is_some(&pools.virtual_pool)) {
+                    let vp =
+                        borrow_global<VirtualPool>(
+                            object::object_address(
+                                &*option::borrow(&pools.virtual_pool)
+                            )
+                        );
+                    option::some(
+                        VirtualPoolDetail {
+                            pool_size: vp.pool_size,
+                            recover_velocity: vp.recover_velocity,
+                            max_ratio: vp.max_ratio,
+                            recover_param: vp.recover_param,
+                            init_pool_amount: vp.init_pool_amount,
+                            ibc_op_init_pool_amount: vp.ibc_op_init_pool_amount,
+                            last_recovered_timestamp: vp.last_recovered_timestamp,
+                            virtual_init_balance: vp.virtual_init_balance,
+                            virtual_ibc_op_init_balance: vp.virtual_ibc_op_init_balance,
+                            peg_keeper_owned_ibc_op_init_balance: vp.peg_keeper_owned_ibc_op_init_balance,
+                            ann: vp.ann,
+                            active: vp.active
+                        }
+                    )
+                } else {
+                    option::none()
+                };
+
+            let stableswap_pool =
+                if (option::is_some(&pools.stableswap_pool)) {
+                    option::some(
+                        stableswap::get_pool(*option::borrow(&pools.stableswap_pool))
+                    )
+                } else {
+                    option::none()
+                };
+
+            vector::push_back(
+                &mut res,
+                PoolsDetailResponse {
+                    ibc_op_init_metadata,
+                    ibc_op_init_denom: coin::symbol(ibc_op_init_metadata),
+                    op_bridge_id: pools.op_bridge_id,
+                    ibc_channel: pools.ibc_channel,
+                    virtual_pool: virtual_pool,
+                    stableswap_pool
+                }
+            )
+        };
+
+        return res
+
+    }
+
+    //
+    // View Function return types
+    //
+
+    struct UnbondResponse has drop {
+        account: address,
+        share_amount: u64,
+        withdraw_amount: u64,
+        release_time: u64
+    }
+
+    public fun unpack_unbond_response(res: UnbondResponse): (address, u64, u64, u64) {
+        return (res.account, res.share_amount, res.withdraw_amount, res.release_time)
+    }
+
+    struct ArbResponse has drop {
+        ibc_op_init_metadata: Object<Metadata>,
+        id: u64,
+        executed_time: u64,
+        init_used: u64,
+        ibc_op_init_sent: u64,
+        triggering_fee: u64
+    }
+
+    public fun unpack_arb_response(res: ArbResponse):
+        (Object<Metadata>, u64, u64, u64, u64, u64) {
+        return (
+            res.ibc_op_init_metadata,
+            res.id,
+            res.executed_time,
+            res.init_used,
+            res.ibc_op_init_sent,
+            res.triggering_fee
+        )
+    }
+
+    struct ModuleStoreResponse has drop {
+        max_change_rate: BigDecimal,
+        emergency_state: bool,
+        admin: address,
+        depositor_owned_init: u64,
+        unbond_period: u64,
+        swap_fee_rate: BigDecimal,
+        arb_fee_rate: BigDecimal,
+        trigger_fee: u64,
+        min_arb_profit: u64,
+        ibc_timeout: u64,
+        max_arb_batch: u64,
+        min_arb_interval: u64,
+        arb_batch_index: u64
+    }
+
+    public fun unpack_module_store_response(
+        res: ModuleStoreResponse
+    ): (
+        BigDecimal,
+        bool,
+        address,
+        u64,
+        u64,
+        BigDecimal,
+        BigDecimal,
+        u64,
+        u64,
+        u64,
+        u64,
+        u64,
+        u64
+    ) {
+        return (
+            res.max_change_rate,
+            res.emergency_state,
+            res.admin,
+            res.depositor_owned_init,
+            res.unbond_period,
+            res.swap_fee_rate,
+            res.arb_fee_rate,
+            res.trigger_fee,
+            res.min_arb_profit,
+            res.ibc_timeout,
+            res.max_arb_batch,
+            res.min_arb_interval,
+            res.arb_batch_index
+        )
+    }
+
+    struct PoolsResponse has drop {
+        ibc_op_init_metadata: Object<Metadata>,
+        ibc_op_init_denom: String,
+        op_bridge_id: u64,
+        ibc_channel: String,
+        virtual_pool: Option<Object<VirtualPool>>,
+        stableswap_pool: Option<Object<Pool>>
+    }
+
+    public fun unpack_pools_response(
+        res: PoolsResponse
+    ): (
+        Object<Metadata>,
+        String,
+        u64,
+        String,
+        Option<Object<VirtualPool>>,
+        Option<Object<Pool>>
+    ) {
+        return (
+            res.ibc_op_init_metadata,
+            res.ibc_op_init_denom,
+            res.op_bridge_id,
+            res.ibc_channel,
+            res.virtual_pool,
+            res.stableswap_pool
+        )
+    }
+
+    struct PoolsDetailResponse has drop {
+        ibc_op_init_metadata: Object<Metadata>,
+        ibc_op_init_denom: String,
+        op_bridge_id: u64,
+        ibc_channel: String,
+        virtual_pool: Option<VirtualPoolDetail>,
+        stableswap_pool: Option<stableswap::PoolResponse>
+    }
+
+    public fun unpack_pools_detail_response(
+        res: PoolsDetailResponse
+    ): (
+        Object<Metadata>,
+        String,
+        u64,
+        String,
+        Option<VirtualPoolDetail>,
+        Option<stableswap::PoolResponse>
+    ) {
+        let PoolsDetailResponse {
+            ibc_op_init_metadata,
+            ibc_op_init_denom,
+            op_bridge_id,
+            ibc_channel,
+            virtual_pool,
+            stableswap_pool
+        } = res;
+        return (
+            ibc_op_init_metadata,
+            ibc_op_init_denom,
+            op_bridge_id,
+            ibc_channel,
+            virtual_pool,
+            stableswap_pool
+        )
+    }
+
+    struct VirtualPoolDetail has drop {
+        pool_size: u64,
+        recover_velocity: BigDecimal,
+        max_ratio: BigDecimal,
+        recover_param: BigDecimal,
+        init_pool_amount: u64,
+        ibc_op_init_pool_amount: u64,
+        last_recovered_timestamp: u64,
+        virtual_init_balance: u64,
+        virtual_ibc_op_init_balance: u64,
+        peg_keeper_owned_ibc_op_init_balance: u64,
+        ann: u64,
+        active: bool
+    }
+
+    public fun unpack_virtual_pool_detail(
+        res: VirtualPoolDetail
+    ): (u64, BigDecimal, BigDecimal, BigDecimal, u64, u64, u64, u64, u64, u64, u64, bool) {
+        return (
+            res.pool_size,
+            res.recover_velocity,
+            res.max_ratio,
+            res.recover_param,
+            res.init_pool_amount,
+            res.ibc_op_init_pool_amount,
+            res.last_recovered_timestamp,
+            res.virtual_init_balance,
+            res.virtual_ibc_op_init_balance,
+            res.peg_keeper_owned_ibc_op_init_balance,
+            res.ann,
+            res.active
+        )
+    }
+
+    //
+    // Admin functions
+    //
+
+    // create new virtual pool
+    public entry fun create_pool(
+        chain: &signer,
+        ibc_op_init_metadata: Object<Metadata>,
+        recover_velocity: BigDecimal,
+        pool_size: u64,
+        ann: u64,
+        max_ratio: BigDecimal,
+        recover_param: BigDecimal,
+        vm_type: u8,
+        hook_contract: String,
+        op_bridge_id: u64,
+        ibc_channel: String
+    ) acquires ModuleStore {
+        assert_is_chain(chain, false);
+        assert!(
+            pool_size > 0,
+            error::invalid_argument(EPOOL_SIZE)
+        );
+        let constructor_ref = object::create_object(@initia_std, false);
+        let extend_ref = object::generate_extend_ref(&constructor_ref);
+        let pool_signer = object::generate_signer(&constructor_ref);
+        let (_, timestamp) = block::get_block_info();
+
+        assert!(
+            vm_type == MOVE || vm_type == COSMWASM || vm_type == EVM,
+            error::invalid_argument(EVM_TYPE)
+        );
+
+        check_bridge_info(
+            op_bridge_id,
+            ibc_channel,
+            ibc_op_init_metadata
+        );
+
+        move_to(
+            &pool_signer,
+            VirtualPool {
+                ibc_op_init_metadata,
+                extend_ref,
+                recover_velocity,
+                pool_size,
+                max_ratio,
+                recover_param,
+                init_pool_amount: pool_size,
+                ibc_op_init_pool_amount: pool_size,
+                last_recovered_timestamp: timestamp,
+                virtual_init_balance: 0,
+                virtual_ibc_op_init_balance: 0,
+                peg_keeper_owned_ibc_op_init_balance: 0,
+                ann,
+                active: true,
+                op_bridge_id,
+                ibc_channel,
+                vm_type,
+                hook_contract,
+                arb_batch_map: table::new()
+            }
+        );
+
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        let pools =
+            borrow_pools_with_default(
+                module_store,
+                ibc_op_init_metadata,
+                op_bridge_id,
+                ibc_channel
+            );
+
+        assert!(
+            option::is_none(&pools.virtual_pool),
+            error::already_exists(EVIRTUAL_POOL_EXISTS)
+        );
+        pools.virtual_pool = option::some(
+            object::object_from_constructor_ref<VirtualPool>(&constructor_ref)
+        );
+
+        event::emit(
+            CreatePoolEvent {
+                ibc_op_init_metadata,
+                recover_velocity,
+                pool_size,
+                ann,
+                max_ratio,
+                recover_param
+            }
+        )
+    }
+
+    // set emergency state
+    public entry fun set_emergency_state(chain: &signer, state: bool) acquires ModuleStore {
+        assert_is_chain(chain, true);
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        module_store.emergency_state = state
+    }
+
+    // deactivate virtual pool
+    public entry fun deactivate(
+        chain: &signer, ibc_op_init_metadata: Object<Metadata>
+    ) acquires ModuleStore, VirtualPool {
+        assert_is_chain(chain, true);
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        let pools = table::borrow(&mut module_store.pools, ibc_op_init_metadata);
+        let pool =
+            borrow_global_mut<VirtualPool>(
+                object::object_address(&*option::borrow(&pools.virtual_pool))
+            );
+        pool.active = false
+    }
+
+    // activate virtual pool
+    public entry fun activate(
+        chain: &signer, ibc_op_init_metadata: Object<Metadata>
+    ) acquires ModuleStore, VirtualPool {
+        assert_is_chain(chain, true);
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        let pools = table::borrow(&mut module_store.pools, ibc_op_init_metadata);
+        let pool =
+            borrow_global_mut<VirtualPool>(
+                object::object_address(&*option::borrow(&pools.virtual_pool))
+            );
+        pool.active = true
+    }
+
+    // change pool size
+    public entry fun change_pool_size(
+        chain: &signer, ibc_op_init_metadata: Object<Metadata>, new_pool_size: u64
+    ) acquires ModuleStore, VirtualPool {
+        assert_is_chain(chain, false);
+        assert!(
+            new_pool_size > 0,
+            error::invalid_argument(EPOOL_SIZE)
+        );
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        let pools = table::borrow(&mut module_store.pools, ibc_op_init_metadata);
+        let pool =
+            borrow_global_mut<VirtualPool>(
+                object::object_address(&*option::borrow(&pools.virtual_pool))
+            );
+
+        let change_rate =
+            if (new_pool_size > pool.pool_size) {
+                bigdecimal::from_ratio_u64(new_pool_size - pool.pool_size, pool.pool_size)
+            } else {
+                bigdecimal::from_ratio_u64(pool.pool_size - new_pool_size, pool.pool_size)
+            };
+
+        assert!(
+            bigdecimal::ge(module_store.max_change_rate, change_rate),
+            error::invalid_argument(EMAX_CHANGE)
+        );
+
+        let depositor_owned_init_increase =
+            if (new_pool_size < pool.pool_size) {
+                /*
+                    Decrease size process
+                    1. Change pool amount as ratio
+                    2. Calculate diff, update peg keeper's balances
+
+                    Net Effect
+                    This action is same with swap INIT > ibc op INIT until pool ratio to be 5:5,
+                    change pool size and sell some portion of ibc op INIT at same price
+                    - INIT and ibc op INIT balances of peg keepers -> INIT decrease ibc op INIT increase,
+                        but INIT decreased amount is smaller than ibc op INIT increased amount.
+                    - Pool ratio doesn't change (= price not change)
+                */
+                let current_init_delta = pool.pool_size - pool.init_pool_amount;
+                let current_ibc_op_init_delta =
+                    pool.ibc_op_init_pool_amount - pool.pool_size;
+
+                let ratio = bigdecimal::from_ratio_u64(new_pool_size, pool.pool_size);
+                pool.init_pool_amount = bigdecimal::mul_by_u64_truncate(
+                    ratio, pool.init_pool_amount
+                );
+                pool.ibc_op_init_pool_amount = bigdecimal::mul_by_u64_truncate(
+                    ratio, pool.ibc_op_init_pool_amount
+                );
+                pool.pool_size = new_pool_size;
+
+                let init_delta = pool.pool_size - pool.init_pool_amount;
+                let ibc_op_init_delta = pool.ibc_op_init_pool_amount - pool.pool_size;
+
+                let net_init_delta = current_init_delta - init_delta;
+                let net_ibc_op_init_delta = current_ibc_op_init_delta
+                    - ibc_op_init_delta;
+
+                pool.virtual_init_balance = pool.virtual_init_balance + net_init_delta;
+                pool.virtual_ibc_op_init_balance = pool.virtual_ibc_op_init_balance
+                    + net_ibc_op_init_delta;
+                pool.peg_keeper_owned_ibc_op_init_balance = pool.peg_keeper_owned_ibc_op_init_balance
+                    + net_ibc_op_init_delta;
+                0
+            } else {
+                /*
+                    Increase size process
+                    1. Swap INIT > ibc init INIT to make 5:5
+                    2. Change pool size
+                    3. Swap back ibc init INIT > INIT
+                        a. If INIT init balance of peg keeper is greater than 0, return it to provider
+
+                    Net Effect
+                    - INIT and ibc init INIT balances of peg keepers -> + for INIT and even for ibc init INIT
+                    - Ratio of pool -> ibc init INIT price decrease
+                */
+
+                // 1. swap to make 5:5
+                let init_swap_amount = pool.pool_size - pool.init_pool_amount;
+                let ibc_op_init_swap_amount = pool.ibc_op_init_pool_amount
+                    - pool.pool_size;
+                // pool.init_pool_amount = pool.pool_size;
+                // pool.ibc_op_init_pool_amount = pool.pool_size;
+                pool.virtual_init_balance = pool.virtual_init_balance
+                    + init_swap_amount;
+                pool.virtual_ibc_op_init_balance = pool.virtual_ibc_op_init_balance
+                    + ibc_op_init_swap_amount;
+                pool.peg_keeper_owned_ibc_op_init_balance = pool.peg_keeper_owned_ibc_op_init_balance
+                    + ibc_op_init_swap_amount;
+
+                // 2. change pool size
+                pool.init_pool_amount = new_pool_size;
+                pool.ibc_op_init_pool_amount = new_pool_size;
+                pool.pool_size = new_pool_size;
+
+                // 3. swap back
+                let return_amount =
+                    get_return_amount(
+                        ibc_op_init_swap_amount,
+                        pool.ibc_op_init_pool_amount,
+                        pool.init_pool_amount,
+                        pool.pool_size,
+                        pool.ann
+                    );
+                pool.ibc_op_init_pool_amount = pool.ibc_op_init_pool_amount
+                    + ibc_op_init_swap_amount;
+                pool.init_pool_amount = pool.init_pool_amount - return_amount;
+                pool.virtual_ibc_op_init_balance = pool.virtual_ibc_op_init_balance
+                    - ibc_op_init_swap_amount;
+                pool.peg_keeper_owned_ibc_op_init_balance = pool.peg_keeper_owned_ibc_op_init_balance
+                    - ibc_op_init_swap_amount;
+
+                if (pool.virtual_init_balance < return_amount) {
+                    let remain = return_amount - pool.virtual_init_balance;
+                    module_store.depositor_owned_init = module_store.depositor_owned_init
+                        + remain;
+                    pool.virtual_init_balance = 0;
+                    remain
+                } else {
+                    pool.virtual_init_balance = pool.virtual_init_balance
+                        - return_amount;
+                    0
+                }
+            };
+
+        event::emit(
+            ChangePoolSizeEvent {
+                ibc_op_init_metadata,
+                pool_size: new_pool_size,
+                depositor_owned_init_increase
+            }
+        )
+    }
+
+    public entry fun update_module_params(
+        chain: &signer,
+        max_change_rate: Option<BigDecimal>,
+        admin: Option<address>,
+        unbond_period: Option<u64>,
+        swap_fee_rate: Option<BigDecimal>,
+        arb_fee_rate: Option<BigDecimal>,
+        trigger_fee: Option<u64>,
+        min_arb_profit: Option<u64>,
+        ibc_timeout: Option<u64>,
+        max_arb_batch: Option<u64>,
+        min_arb_interval: Option<u64>
+    ) acquires ModuleStore {
+        assert_is_chain(chain, false);
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+
+        if (option::is_some(&max_change_rate)) {
+            module_store.max_change_rate = option::extract(&mut max_change_rate);
+        };
+
+        if (option::is_some(&admin)) {
+            module_store.admin = option::extract(&mut admin);
+        };
+
+        if (option::is_some(&unbond_period)) {
+            module_store.unbond_period = option::extract(&mut unbond_period);
+        };
+
+        if (option::is_some(&swap_fee_rate)) {
+            module_store.swap_fee_rate = option::extract(&mut swap_fee_rate);
+        };
+
+        if (option::is_some(&arb_fee_rate)) {
+            module_store.arb_fee_rate = option::extract(&mut arb_fee_rate);
+        };
+
+        if (option::is_some(&trigger_fee)) {
+            module_store.trigger_fee = option::extract(&mut trigger_fee);
+        };
+
+        if (option::is_some(&min_arb_profit)) {
+            module_store.min_arb_profit = option::extract(&mut min_arb_profit);
+        };
+
+        if (option::is_some(&ibc_timeout)) {
+            module_store.ibc_timeout = option::extract(&mut ibc_timeout);
+        };
+
+        if (option::is_some(&max_arb_batch)) {
+            module_store.max_arb_batch = option::extract(&mut max_arb_batch);
+        };
+
+        if (option::is_some(&min_arb_interval)) {
+            module_store.min_arb_interval = option::extract(&mut min_arb_interval);
+        };
+
+        assert!(
+            module_store.min_arb_profit > module_store.trigger_fee,
+            error::invalid_argument(ESMALL_ARB_PROFIT)
+        )
+    }
+
+    public entry fun update_pool_params(
+        chain: &signer,
+        ibc_op_init_metadata: Object<Metadata>,
+        recover_velocity: Option<BigDecimal>,
+        ann: Option<u64>,
+        max_ratio: Option<BigDecimal>,
+        recover_param: Option<BigDecimal>,
+        hook_contract: Option<String>
+    ) acquires ModuleStore, VirtualPool {
+        assert_is_chain(chain, false);
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        let pools = table::borrow(&mut module_store.pools, ibc_op_init_metadata);
+        let pool =
+            borrow_global_mut<VirtualPool>(
+                object::object_address(&*option::borrow(&pools.virtual_pool))
+            );
+
+        if (option::is_some(&recover_velocity)) {
+            pool.recover_velocity = option::extract(&mut recover_velocity);
+        };
+
+        // It is okay to change ann immediately cause there are no real provider
+        if (option::is_some(&ann)) {
+            pool.ann = option::extract(&mut ann);
+        };
+
+        if (option::is_some(&max_ratio)) {
+            pool.max_ratio = option::extract(&mut max_ratio);
+        };
+
+        if (option::is_some(&recover_param)) {
+            pool.recover_param = option::extract(&mut recover_param);
+        };
+
+        if (option::is_some(&hook_contract)) {
+            pool.hook_contract = option::extract(&mut hook_contract);
+        };
+
+        event::emit(
+            UpdatePoolParamsEvent {
+                ibc_op_init_metadata,
+                recover_velocity,
+                ann,
+                max_ratio,
+                recover_param,
+                hook_contract
+            }
+        )
+    }
+
+    //
+    // Entry Functions
+    //
+
+    public entry fun provide(
+        account: &signer, amount: u64, min_return_amount: Option<u64>
+    ) acquires ModuleStore {
+        let init = primary_fungible_store::withdraw(account, init_metadata(), amount);
+        let share_token = provide_internal(init);
+        assert_min_amount(&share_token, min_return_amount);
+        primary_fungible_store::deposit(signer::address_of(account), share_token);
+    }
+
+    public entry fun unbond(account: &signer, amount: u64) acquires ModuleStore {
+        let share_token =
+            primary_fungible_store::withdraw(account, share_token_metadata(), amount);
+        unbond_internal(account, share_token);
+    }
+
+    public entry fun withdraw_unbond(account: &signer, release_time: u64) acquires ModuleStore {
+        let addr = signer::address_of(account);
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+
+        // check emergency
+        assert!(
+            !module_store.emergency_state,
+            error::invalid_state(EEMERGENCY)
+        );
+
+        // remove unbond entity
+        let key = generate_unbond_key(addr, release_time);
+        let UnbondEntity { account: _, share_amount, withdraw_amount, release_time } =
+            table::remove(&mut module_store.unbond_wait_list, key);
+
+        // check release time
+        let (_, timestamp) = block::get_block_info();
+        assert!(
+            timestamp >= release_time,
+            error::invalid_state(ERELEASE_TIME)
+        );
+
+        // release init
+        let module_signer =
+            object::generate_signer_for_extending(&module_store.extend_ref);
+        primary_fungible_store::transfer(
+            &module_signer,
+            init_metadata(),
+            addr,
+            withdraw_amount
+        );
+
+        event::emit(
+            WithdrawUnbondEvent {
+                account: addr,
+                share_amount,
+                withdraw_amount,
+                release_time
+            }
+        );
+    }
+
+    public entry fun swap(
+        account: &signer,
+        offer_asset_metadata: Object<Metadata>,
+        return_asset_metadata: Object<Metadata>,
+        amount: u64,
+        min_return_amount: Option<u64>
+    ) acquires ModuleStore, VirtualPool {
+        let offer_asset =
+            primary_fungible_store::withdraw(account, offer_asset_metadata, amount);
+
+        let return_asset = swap_internal(offer_asset, return_asset_metadata);
+        assert_min_amount(&return_asset, min_return_amount);
+
+        primary_fungible_store::deposit(signer::address_of(account), return_asset);
+    }
+
+    public entry fun finalize_arb(
+        account: &signer,
+        arb_index: u64,
+        output_index: u64,
+        withdrawal_proofs: vector<String>,
+        sender: address,
+        sequence: u64,
+        version: String,
+        state_root: String,
+        storage_root: String,
+        latest_block_hash: String
+    ) acquires ModuleStore, VirtualPool {
+        // check arb info
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+        let pool_obj =
+            table::borrow(
+                &module_store.global_arb_batch_map,
+                table_key::encode_u64(arb_index)
+            );
+        let pool = borrow_global<VirtualPool>(object::object_address(&*pool_obj));
+        let arb_info =
+            table::borrow(
+                &pool.arb_batch_map,
+                table_key::encode_u64(arb_index)
+            );
+
+        // execute finalize token withdrawal
+        let pool_signer = object::generate_signer_for_extending(&pool.extend_ref);
+        let withdrawal_msg =
+            generate_finalize_token_withdrawal_msg(
+                pool.op_bridge_id,
+                output_index,
+                withdrawal_proofs,
+                sender,
+                signer::address_of(&pool_signer),
+                sequence,
+                string::utf8(b"uinit"),
+                arb_info.ibc_op_init_sent,
+                version,
+                state_root,
+                storage_root,
+                latest_block_hash
+            );
+        cosmos::stargate(&pool_signer, withdrawal_msg);
+
+        // execute hook
+        let module_signer =
+            object::generate_signer_for_extending(&module_store.extend_ref);
+        cosmos::move_execute(
+            &module_signer,
+            @initia_std,
+            string::utf8(b"minitswap"),
+            string::utf8(b"finalize_arb_hook"),
+            vector[],
+            vector[
+                bcs::to_bytes(&arb_index),
+                bcs::to_bytes(&signer::address_of(account))
+            ]
+        );
+    }
+
+    public entry fun finalize_arb_hook(
+        module_signer: &signer, arb_index: u64, executor: address
+    ) acquires ModuleStore, VirtualPool {
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        assert!(
+            signer::address_of(module_signer)
+                == object::address_from_extend_ref(&module_store.extend_ref),
+            error::permission_denied(EUNAUTHORIZED)
+        );
+
+        let pool_obj =
+            table::remove(
+                &mut module_store.global_arb_batch_map,
+                table_key::encode_u64(arb_index)
+            );
+        let pool = borrow_global_mut<VirtualPool>(object::object_address(&pool_obj));
+        let ArbInfo { executed_time: _, init_used, ibc_op_init_sent, triggering_fee } =
+            table::remove(
+                &mut pool.arb_batch_map,
+                table_key::encode_u64(arb_index)
+            );
+
+        assert!(pool.active, error::invalid_state(EINACTIVE));
+
+        let pool_signer = object::generate_signer_for_extending(&pool.extend_ref);
+
+        // update pegkeeper owned balance
+        pool.peg_keeper_owned_ibc_op_init_balance = pool.peg_keeper_owned_ibc_op_init_balance
+            - ibc_op_init_sent;
+
+        // transfer trigger fee
+        primary_fungible_store::transfer(
+            &pool_signer,
+            init_metadata(),
+            executor,
+            triggering_fee
+        );
+
+        // transfer leftover to module_addr
+        let leftover_amount = ibc_op_init_sent - triggering_fee;
+        primary_fungible_store::transfer(
+            &pool_signer,
+            init_metadata(),
+            signer::address_of(module_signer),
+            leftover_amount
+        );
+
+        // update depositor owned init
+        let in_house_arb_profit = leftover_amount - init_used;
+        module_store.depositor_owned_init = module_store.depositor_owned_init
+            + in_house_arb_profit;
+
+        // emit event
+        event::emit(
+            FinalizeArbEvent {
+                arb_index,
+                pool: pool_obj,
+                init_used,
+                ibc_op_init_sent,
+                triggering_fee
+            }
+        );
+    }
+
+    // stableswap
+
+    public entry fun create_stableswap_pool(
+        account: &signer,
+        op_bridge_id: u64,
+        ibc_channel: String,
+        ibc_op_init_metadata: Object<Metadata>,
+        init_amount: u64,
+        ibc_op_init_amount: u64
+    ) acquires ModuleStore {
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        let (_, ibc_denom) =
+            check_bridge_info(
+                op_bridge_id,
+                ibc_channel,
+                ibc_op_init_metadata
+            );
+
+        let creator = object::generate_signer_for_extending(&module_store.extend_ref);
+        let symbol = string::utf8(b"INIT - ");
+        string::append(&mut symbol, ibc_denom);
+
+        let coins: vector<FungibleAsset> = vector[
+            coin::withdraw(account, init_metadata(), init_amount),
+            coin::withdraw(
+                account,
+                ibc_op_init_metadata,
+                ibc_op_init_amount
+            )
+        ];
+
+        let liquidity_token =
+            stableswap::create_pool(
+                &creator,
+                symbol,
+                symbol,
+                module_store.stableswap_swap_fee_rate,
+                coins,
+                module_store.stableswap_ann
+            );
+        let metadata = fungible_asset::metadata_from_asset(&liquidity_token);
+        let pool = object::convert<Metadata, Pool>(metadata);
+
+        let pools =
+            borrow_pools_with_default(
+                module_store,
+                ibc_op_init_metadata,
+                op_bridge_id,
+                ibc_channel
+            );
+        pools.stableswap_pool = option::some(object::convert<Metadata, Pool>(metadata));
+
+        primary_fungible_store::deposit(signer::address_of(account), liquidity_token);
+        event::emit(CreateStableswapPoolEvent { ibc_op_init_metadata, pool });
+    }
+
+    public fun provide_internal(init: FungibleAsset): FungibleAsset acquires ModuleStore {
+        // check asset metadata
+        assert!(
+            is_init(&init),
+            error::invalid_argument(ENOT_INIT)
+        );
+        let provide_amount = fungible_asset::amount(&init);
+
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+
+        // check emergency
+        assert!(
+            !module_store.emergency_state,
+            error::invalid_state(EEMERGENCY)
+        );
+
+        // calculate share amount
+        let total_share = total_share();
+        let share_amount =
+            if (total_share == 0) {
+                provide_amount
+            } else {
+                mul_div(
+                    provide_amount,
+                    (total_share as u64),
+                    module_store.depositor_owned_init
+                )
+            };
+
+        // update depositor owned init
+        module_store.depositor_owned_init = module_store.depositor_owned_init
+            + provide_amount;
+
+        // deposit token to module
+        let module_addr = object::address_from_extend_ref(&module_store.extend_ref);
+        primary_fungible_store::deposit(module_addr, init);
+
+        // emit event
+        event::emit<ProvideEvent>(ProvideEvent { provide_amount, share_amount });
+
+        // mint share token
+        coin::mint(&module_store.mint_cap, share_amount)
+    }
+
+    public fun unbond_internal(
+        account: &signer, share_token: FungibleAsset
+    ) acquires ModuleStore {
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+
+        // check emergency
+        assert!(
+            !module_store.emergency_state,
+            error::invalid_state(EEMERGENCY)
+        );
+
+        // check metadata
+        let share_token_metadata = fungible_asset::metadata_from_asset(&share_token);
+        assert!(
+            share_token_metadata == share_token_metadata(),
+            error::invalid_argument(ENOT_SHARE_TOKEN)
+        );
+
+        // calculate withdraw amount
+        let share_amount = fungible_asset::amount(&share_token);
+        let total_share = total_share();
+        let withdraw_amount =
+            mul_div(
+                share_amount,
+                module_store.depositor_owned_init,
+                total_share
+            );
+
+        // decrease depositor owned init
+        module_store.depositor_owned_init = module_store.depositor_owned_init
+            - withdraw_amount;
+
+        // burn share token
+        coin::burn(&module_store.burn_cap, share_token);
+
+        // get release time
+        let (_, timestamp) = block::get_block_info();
+        let release_time = timestamp + module_store.unbond_period;
+
+        // create and store withdraw entiry
+        let withdraw_entity = UnbondEntity {
+            account: signer::address_of(account),
+            share_amount,
+            withdraw_amount,
+            release_time
+        };
+        let key = generate_unbond_key(signer::address_of(account), release_time);
+        table::add(
+            &mut module_store.unbond_wait_list,
+            key,
+            withdraw_entity
+        );
+
+        // emit event
+        event::emit<UnbondEvent>(
+            UnbondEvent {
+                account: signer::address_of(account),
+                share_amount,
+                withdraw_amount,
+                release_time
+            }
+        );
+    }
+
+    public fun swap_internal(
+        offer_asset: FungibleAsset, return_metadata: Object<Metadata>
+    ): FungibleAsset acquires ModuleStore, VirtualPool {
+        let is_init_offered = is_init(&offer_asset);
+        let offer_metadata = fungible_asset::metadata_from_asset(&offer_asset);
+        let offer_amount = fungible_asset::amount(&offer_asset);
+        let ibc_op_init_metadata = offer_metadata;
+        let (module_store, pool, module_signer, pool_signer) =
+            if (is_init_offered) {
+                ibc_op_init_metadata = return_metadata;
+                borrow_all_mut(return_metadata)
+            } else {
+                borrow_all_mut(offer_metadata)
+            };
+        assert!(pool.active, error::invalid_state(EINACTIVE));
+
+        // init offered, do user swap first
+        let (
+            peg_keeper_offer_amount,
+            peg_keeper_return_amount,
+            return_asset,
+            init_swap_fee_amount,
+            init_arb_fee_amount,
+            ibc_op_init_swap_fee_amount,
+            ibc_op_init_arb_fee_amount
+        ) =
+            if (is_init_offered) {
+                // user swap
+                let (
+                    return_asset, swap_fee_amount, arb_fee_amount, depositor_return_amount
+                ) =
+                    user_swap(
+                        offer_asset,
+                        return_metadata,
+                        module_store,
+                        pool,
+                        module_signer,
+                        pool_signer,
+                        is_init_offered
+                    );
+
+                // peg keeper swap
+                let (peg_keeper_offer_amount, peg_keeper_return_amount) =
+                    peg_keeper_swap(pool);
+
+                // to prevent div by zero
+                let init_arb_fee_amount =
+                    if (arb_fee_amount == 0) { 0 }
+                    else {
+                        mul_div(
+                            depositor_return_amount,
+                            arb_fee_amount,
+                            arb_fee_amount + swap_fee_amount
+                        )
+                    };
+
+                let init_swap_fee_amount = depositor_return_amount
+                    - init_arb_fee_amount;
+
+                (
+                    peg_keeper_offer_amount,
+                    peg_keeper_return_amount,
+                    return_asset,
+                    init_swap_fee_amount,
+                    init_arb_fee_amount,
+                    swap_fee_amount,
+                    arb_fee_amount
+                )
+                // if ibc op init offered, do peg keeper swap first
+            } else {
+                // peg keeper swap
+                let (peg_keeper_offer_amount, peg_keeper_return_amount) =
+                    peg_keeper_swap(pool);
+
+                // user swap
+                let (return_asset, swap_fee_amount, arb_fee_amount, _) =
+                    user_swap(
+                        offer_asset,
+                        return_metadata,
+                        module_store,
+                        pool,
+                        module_signer,
+                        pool_signer,
+                        is_init_offered
+                    );
+
+                (
+                    peg_keeper_offer_amount,
+                    peg_keeper_return_amount,
+                    return_asset,
+                    swap_fee_amount,
+                    arb_fee_amount,
+                    0,
+                    0
+                )
+            };
+
+        // check arb
+        check_arb(module_store, pool, ibc_op_init_metadata);
+
+        event::emit<SwapEvent>(
+            SwapEvent {
+                offer_coin: offer_metadata,
+                return_coin: return_metadata,
+                peg_keeper_offer_amount, // always init
+                peg_keeper_return_amount, // always ibc op init
+                offer_amount,
+                return_amount: fungible_asset::amount(&return_asset),
+                init_swap_fee_amount,
+                init_arb_fee_amount,
+                ibc_op_init_swap_fee_amount,
+                ibc_op_init_arb_fee_amount
+            }
+        );
+
+        return_asset
+    }
+
+    //
+    // ibc async callback
+    //
+
+    public entry fun ibc_ack(
+        pool_signer: &signer, callback_id: u64, success: bool
+    ) acquires ModuleStore, VirtualPool {
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        let pool_obj =
+            table::borrow(
+                &mut module_store.global_arb_batch_map,
+                table_key::encode_u64(callback_id)
+            );
+        let pool = borrow_global_mut<VirtualPool>(object::object_address(&*pool_obj));
+        assert!(
+            signer::address_of(pool_signer)
+                == object::address_from_extend_ref(&pool.extend_ref),
+            error::permission_denied(EUNAUTHORIZED)
+        );
+
+        // do nothing
+        if (success) { return };
+
+        revert_arb_state(callback_id);
+    }
+
+    public entry fun ibc_timeout(
+        pool_signer: &signer, callback_id: u64
+    ) acquires ModuleStore, VirtualPool {
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        let pool_obj =
+            table::borrow(
+                &mut module_store.global_arb_batch_map,
+                table_key::encode_u64(callback_id)
+            );
+        let pool = borrow_global_mut<VirtualPool>(object::object_address(&*pool_obj));
+        assert!(
+            signer::address_of(pool_signer)
+                == object::address_from_extend_ref(&pool.extend_ref),
+            error::permission_denied(EUNAUTHORIZED)
+        );
+
+        revert_arb_state(callback_id);
+    }
+
+    fun revert_arb_state(callback_id: u64) acquires ModuleStore, VirtualPool {
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        let pool_obj =
+            table::remove(
+                &mut module_store.global_arb_batch_map,
+                table_key::encode_u64(callback_id)
+            );
+        let pool = borrow_global_mut<VirtualPool>(object::object_address(&pool_obj));
+        let ArbInfo { executed_time: _, init_used, ibc_op_init_sent, triggering_fee } =
+            table::remove(
+                &mut pool.arb_batch_map,
+                table_key::encode_u64(callback_id)
+            );
+        pool.virtual_init_balance = pool.virtual_init_balance + init_used;
+        pool.virtual_ibc_op_init_balance = pool.virtual_ibc_op_init_balance
+            + ibc_op_init_sent;
+
+        event::emit<RevertArbEvent>(
+            RevertArbEvent {
+                arb_index: callback_id,
+                pool: pool_obj,
+                init_used,
+                ibc_op_init_sent, // always ibc op init
+                triggering_fee
+            }
+        );
+
+    }
+
+    //
+    // Helper function
+    //
+
+    inline fun borrow_all_mut(
+        metadata: Object<Metadata>
+    ): (&mut ModuleStore, &mut VirtualPool, signer, signer) acquires ModuleStore, VirtualPool {
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        let module_signer =
+            object::generate_signer_for_extending(&module_store.extend_ref);
+        let pool_addr =
+            object::object_address(
+                &*option::borrow(
+                    &table::borrow(&module_store.pools, metadata).virtual_pool
+                )
+            );
+        let pool = borrow_global_mut<VirtualPool>(pool_addr);
+        let pool_signer = object::generate_signer_for_extending(&pool.extend_ref);
+        (module_store, pool, module_signer, pool_signer)
+    }
+
+    inline fun borrow_all(
+        metadata: Object<Metadata>
+    ): (&ModuleStore, &VirtualPool) acquires ModuleStore, VirtualPool {
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+        let pool_addr =
+            object::object_address(
+                &*option::borrow(
+                    &table::borrow(&module_store.pools, metadata).virtual_pool
+                )
+            );
+        let pool = borrow_global<VirtualPool>(pool_addr);
+        (module_store, pool)
+    }
+
+    inline fun virtual_pool_exists(metadata: Object<Metadata>): bool acquires ModuleStore {
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+        if (!table::contains(&module_store.pools, metadata)) { false }
+        else {
+            option::is_some(&table::borrow(&module_store.pools, metadata).virtual_pool)
+        }
+    }
+
+    inline fun calc_peg_keeper_swap(pool: &VirtualPool): (u64, u64) acquires ModuleStore, VirtualPool {
+        let (_, timestamp) = block::get_block_info();
+
+        let imbalance =
+            bigdecimal::from_ratio_u64(
+                pool.peg_keeper_owned_ibc_op_init_balance
+                    + pool.ibc_op_init_pool_amount - pool.pool_size, // same with real ibc op init balance
+                pool.pool_size
+            );
+        // Peg keeper swap
+        let r_fr = get_fully_recovered_ratio(
+            imbalance, pool.max_ratio, pool.recover_param
+        );
+        let current_ratio =
+            bigdecimal::from_ratio_u64(
+                pool.ibc_op_init_pool_amount,
+                pool.init_pool_amount + pool.ibc_op_init_pool_amount
+            );
+        let time_diff = timestamp - pool.last_recovered_timestamp;
+        if (bigdecimal::gt(current_ratio, r_fr) && time_diff != 0) {
+            let (x_fr, _) =
+                get_fully_recovered_pool_amounts(pool.pool_size, r_fr, pool.ann);
+            let max_recover_amount =
+                bigdecimal::mul_by_u64_truncate(pool.recover_velocity, time_diff);
+            let swap_amount_to_reach_fr =
+                if (x_fr > pool.init_pool_amount) {
+                    x_fr - pool.init_pool_amount
+                } else { 0 };
+            let swap_amount =
+                if (swap_amount_to_reach_fr < max_recover_amount) {
+                    swap_amount_to_reach_fr
+                } else {
+                    max_recover_amount
+                };
+
+            let return_amount =
+                get_return_amount(
+                    swap_amount,
+                    pool.init_pool_amount,
+                    pool.ibc_op_init_pool_amount,
+                    pool.pool_size,
+                    pool.ann
+                );
+
+            (swap_amount, return_amount)
+        } else { (0, 0) }
+    }
+
+    fun user_swap(
+        offer_asset: FungibleAsset,
+        return_metadata: Object<Metadata>,
+        module_store: &mut ModuleStore,
+        pool: &mut VirtualPool,
+        module_signer: signer,
+        pool_signer: signer,
+        is_init_offered: bool
+    ): (FungibleAsset, u64, u64, u64) {
+        let module_addr = signer::address_of(&module_signer);
+        let pool_addr = signer::address_of(&pool_signer);
+
+        let offer_amount = fungible_asset::amount(&offer_asset);
+        let arb_fee_amount = 0;
+        let (return_asset, swap_fee_amount, depositor_return_amount) =
+            if (is_init_offered) {
+                primary_fungible_store::deposit(module_addr, offer_asset);
+
+                // do swap
+                let return_amount =
+                    get_return_amount(
+                        offer_amount,
+                        pool.init_pool_amount,
+                        pool.ibc_op_init_pool_amount,
+                        pool.pool_size,
+                        pool.ann
+                    );
+                pool.init_pool_amount = pool.init_pool_amount + offer_amount;
+                pool.ibc_op_init_pool_amount = pool.ibc_op_init_pool_amount
+                    - return_amount;
+
+                assert!(
+                    pool.ibc_op_init_pool_amount >= pool.pool_size
+                        && pool.init_pool_amount <= pool.pool_size,
+                    error::invalid_state(EIBC_OP_INIT_PRICE_TOO_LOW)
+                );
+
+                // take swap fee
+                let swap_fee_amount =
+                    bigdecimal::mul_by_u64_ceil(
+                        module_store.swap_fee_rate, return_amount
+                    );
+                return_amount = return_amount - swap_fee_amount;
+
+                // take arb fee
+                let arb_profit =
+                    if (return_amount > offer_amount) {
+                        return_amount - offer_amount
+                    } else { 0 };
+                arb_fee_amount = bigdecimal::mul_by_u64_ceil(
+                    module_store.arb_fee_rate, arb_profit
+                );
+                return_amount = return_amount - arb_fee_amount;
+                let total_fee_amount = swap_fee_amount + arb_fee_amount;
+
+                // swap ibc op init fee to init for depositor
+                let depositor_return_amount =
+                    get_return_amount(
+                        total_fee_amount,
+                        pool.ibc_op_init_pool_amount,
+                        pool.init_pool_amount,
+                        pool.pool_size,
+                        pool.ann
+                    );
+                pool.init_pool_amount = pool.init_pool_amount - depositor_return_amount;
+                pool.ibc_op_init_pool_amount = pool.ibc_op_init_pool_amount
+                    + total_fee_amount;
+
+                // increase depositor amount
+                module_store.depositor_owned_init = module_store.depositor_owned_init
+                    + depositor_return_amount;
+
+                (
+                    primary_fungible_store::withdraw(
+                        &pool_signer, return_metadata, return_amount
+                    ),
+                    swap_fee_amount,
+                    depositor_return_amount
+                )
+            } else {
+                primary_fungible_store::deposit(pool_addr, offer_asset);
+
+                // do swap
+                let return_amount =
+                    get_return_amount(
+                        offer_amount,
+                        pool.ibc_op_init_pool_amount,
+                        pool.init_pool_amount,
+                        pool.pool_size,
+                        pool.ann
+                    );
+                pool.init_pool_amount = pool.init_pool_amount - return_amount;
+                pool.ibc_op_init_pool_amount = pool.ibc_op_init_pool_amount
+                    + offer_amount;
+
+                // take swap fee
+                let swap_fee_amount =
+                    bigdecimal::mul_by_u64_ceil(
+                        module_store.swap_fee_rate, return_amount
+                    );
+                let return_amount = return_amount - swap_fee_amount;
+
+                // increase depositor amount
+                module_store.depositor_owned_init = module_store.depositor_owned_init
+                    + swap_fee_amount;
+
+                (
+                    primary_fungible_store::withdraw(
+                        &module_signer,
+                        return_metadata,
+                        return_amount
+                    ),
+                    swap_fee_amount,
+                    swap_fee_amount
+                )
+            };
+
+        (return_asset, swap_fee_amount, arb_fee_amount, depositor_return_amount)
+    }
+
+    fun peg_keeper_swap(pool: &mut VirtualPool): (u64, u64) {
+        let (_, timestamp) = block::get_block_info();
+
+        let (peg_keeper_offer_amount, peg_keeper_return_amount) =
+            calc_peg_keeper_swap(pool);
+        pool.init_pool_amount = pool.init_pool_amount + peg_keeper_offer_amount;
+        pool.ibc_op_init_pool_amount = pool.ibc_op_init_pool_amount
+            - peg_keeper_return_amount;
+        pool.virtual_init_balance = pool.virtual_init_balance + peg_keeper_offer_amount;
+        pool.virtual_ibc_op_init_balance = pool.virtual_ibc_op_init_balance
+            + peg_keeper_return_amount;
+        pool.peg_keeper_owned_ibc_op_init_balance = pool.peg_keeper_owned_ibc_op_init_balance
+            + peg_keeper_return_amount;
+        pool.last_recovered_timestamp = timestamp;
+
+        (peg_keeper_offer_amount, peg_keeper_return_amount)
+    }
+
+    fun check_arb(
+        module_store: &mut ModuleStore,
+        pool: &mut VirtualPool,
+        ibc_op_init_metadata: Object<Metadata>
+    ) {
+        // check max arb batch
+        if (table::length(&pool.arb_batch_map) > module_store.max_arb_batch) { return };
+
+        let expected_arb_profit =
+            pool.virtual_ibc_op_init_balance - pool.virtual_init_balance;
+
+        // check min_arb_profit
+        if (expected_arb_profit < module_store.min_arb_profit) { return };
+
+        // get latest arb timestamp
+        let iter = table::iter(
+            &pool.arb_batch_map,
+            option::none(),
+            option::none(),
+            2
+        );
+
+        let last_arb_timestamp =
+            if (table::prepare(iter)) {
+                let (_, value) = table::next<vector<u8>, ArbInfo>(iter);
+                value.executed_time
+            } else { 0 };
+
+        // check min arb interval
+        let (_, timestamp) = block::get_block_info();
+        if (timestamp < module_store.min_arb_interval + last_arb_timestamp) { return };
+
+        // get new arb batch index
+        let arb_index = module_store.arb_batch_index;
+        module_store.arb_batch_index = module_store.arb_batch_index + 1;
+
+        // set arb info
+        let arb_info = ArbInfo {
+            executed_time: timestamp,
+            init_used: pool.virtual_init_balance,
+            ibc_op_init_sent: pool.virtual_ibc_op_init_balance,
+            triggering_fee: module_store.trigger_fee
+        };
+
+        // reset peg keeper balance
+        pool.virtual_init_balance = 0;
+        pool.virtual_ibc_op_init_balance = 0;
+
+        // send ibc message with hook
+        send_ibc_message(
+            module_store,
+            pool,
+            arb_index,
+            ibc_op_init_metadata,
+            arb_info.ibc_op_init_sent
+        );
+
+        // emit event
+        let pools = table::borrow(&mut module_store.pools, ibc_op_init_metadata);
+        let pool_obj = *option::borrow(&pools.virtual_pool);
+        event::emit(
+            InitiateArbEvent {
+                arb_index,
+                pool: pool_obj,
+                executed_time: arb_info.executed_time,
+                init_used: arb_info.init_used,
+                ibc_op_init_sent: arb_info.ibc_op_init_sent,
+                triggering_fee: arb_info.triggering_fee
+            }
+        );
+
+        // store arb info
+        table::add(
+            &mut module_store.global_arb_batch_map,
+            table_key::encode_u64(arb_index),
+            pool_obj
+        );
+        table::add(
+            &mut pool.arb_batch_map,
+            table_key::encode_u64(arb_index),
+            arb_info
+        );
+    }
+
+    fun borrow_pools_with_default(
+        module_store: &mut ModuleStore,
+        ibc_op_init_metadata: Object<Metadata>,
+        op_bridge_id: u64,
+        ibc_channel: String
+    ): &mut Pools {
+        if (table::contains(&module_store.pools, ibc_op_init_metadata)) {
+            table::borrow_mut(&mut module_store.pools, ibc_op_init_metadata)
+        } else {
+            table::add(
+                &mut module_store.pools,
+                ibc_op_init_metadata,
+                Pools {
+                    op_bridge_id,
+                    ibc_channel,
+                    virtual_pool: option::none(),
+                    stableswap_pool: option::none()
+                }
+            );
+
+            table::borrow_mut(&mut module_store.pools, ibc_op_init_metadata)
+        }
+    }
+
+    fun send_ibc_message(
+        module_store: &ModuleStore,
+        pool: &mut VirtualPool,
+        batch_index: u64,
+        ibc_op_init_metadata: Object<Metadata>,
+        amount: u64
+    ) {
+        // create memo (ibc hook)
+        let receiver = to_sdk(object::address_from_extend_ref(&pool.extend_ref));
+        let op_denom = get_op_denom(pool.op_bridge_id, string::utf8(b"uinit"));
+
+        // set async callback
+        let (ibc_receiver, memo) =
+            generate_ibc_message(
+                pool.vm_type,
+                pool.hook_contract,
+                batch_index,
+                receiver,
+                op_denom,
+                amount
+            );
+
+        // execute ibc transfer
+        let pool_signer = object::generate_signer_for_extending(&pool.extend_ref);
+        let (_, timestamp) = block::get_block_info();
+
+        cosmos::transfer(
+            &pool_signer,
+            ibc_receiver,
+            ibc_op_init_metadata,
+            amount,
+            string::utf8(b"transfer"),
+            pool.ibc_channel,
+            0,
+            0,
+            (timestamp + module_store.ibc_timeout) * 1000000000,
+            memo
+        )
+    }
+
+    struct IBCMemo has copy, drop {
+        _move_: MemoMove,
+        wasm: Option<MemoWasm>,
+        evm: Option<MemoEvm>
+    }
+
+    struct MemoMove has copy, drop {
+        message: Option<MemoMoveMessage>,
+        async_callback: MemoAsyncCallback
+    }
+
+    struct MemoAsyncCallback has copy, drop {
+        id: u64,
+        module_address: address,
+        module_name: String
+    }
+
+    struct MemoMoveMessage has copy, drop {
+        module_address: String,
+        module_name: String,
+        function_name: String,
+        type_args: vector<String>,
+        args: vector<String>
+    }
+
+    struct MemoWasm has copy, drop {
+        message: MemoWasmMessage
+    }
+
+    struct MemoWasmMessage has copy, drop {
+        contracts: String,
+        funds: vector<MemoWasmFunds>,
+        msg: MemoWasmMinitswapHook
+    }
+
+    struct MemoWasmFunds has copy, drop {
+        denom: String,
+        amount: String
+    }
+
+    struct MemoWasmMinitswapHook has copy, drop {
+        minitswap_hook: MemoWasmMinitswapHookMsg
+    }
+
+    struct MemoWasmMinitswapHookMsg has copy, drop {
+        receiver: String
+    }
+
+    struct MemoEvm has copy, drop {
+        message: MemoEvmMessage
+    }
+
+    struct MemoEvmMessage has copy, drop {
+        contract_addr: String,
+        input: String,
+        value: String,
+        access_list: vector<MemoEvmAccessList>
+    }
+
+    struct MemoEvmAccessList has copy, drop {
+        address: String,
+        storage_keys: vector<String>
+    }
+
+    fun generate_ibc_message(
+        vm_type: u8,
+        hook_contract: String,
+        batch_index: u64,
+        receiver: String,
+        op_denom: String,
+        amount: u64
+    ): (String, String) {
+        let memo = IBCMemo {
+            _move_: MemoMove {
+                message: option::none(),
+                async_callback: MemoAsyncCallback {
+                    id: batch_index,
+                    module_address: @initia_std,
+                    module_name: string::utf8(b"minitswap")
+                }
+            },
+            wasm: option::none(),
+            evm: option::none()
+        };
+
+        // set hook message
+        let ibc_receiver =
+            if (vm_type == MOVE) {
+                memo._move_.message = option::some(
+                    MemoMoveMessage {
+                        module_address: hook_contract,
+                        module_name: string::utf8(b"minitswap_hook"),
+                        function_name: string::utf8(b"minitswap_hook"),
+                        type_args: vector[],
+                        args: vector[
+                            base64::to_string(bcs::to_bytes(&op_denom)),
+                            base64::to_string(bcs::to_bytes(&amount)),
+                            base64::to_string(bcs::to_bytes(&receiver))
+                        ]
+                    }
+                );
+
+                let ibc_receiver = hook_contract;
+                string::append(
+                    &mut ibc_receiver,
+                    string::utf8(b"::minitswap_hook::minitswap_hook")
+                );
+                ibc_receiver
+            } else if (vm_type == COSMWASM) {
+                memo.wasm = option::some(
+                    MemoWasm {
+                        message: MemoWasmMessage {
+                            contracts: hook_contract,
+                            funds: vector[MemoWasmFunds {
+                                denom: op_denom,
+                                amount: to_string(&amount)
+                            }],
+                            msg: MemoWasmMinitswapHook {
+                                minitswap_hook: MemoWasmMinitswapHookMsg { receiver }
+                            }
+                        }
+                    }
+                );
+
+                hook_contract
+            } else if (vm_type == EVM) {
+                memo.evm = option::some(
+                    MemoEvm {
+                        message: MemoEvmMessage {
+                            contract_addr: hook_contract,
+                            input: create_evm_input(&op_denom, amount, &receiver),
+                            value: string::utf8(b"0"),
+                            access_list: vector[]
+                        }
+                    }
+                );
+
+                hook_contract
+            } else {
+                abort(error::invalid_argument(EVM_TYPE))
+            };
+
+        (ibc_receiver, json::marshal_to_string(&memo))
+    }
+
+    // abi encode of minitswapHook(string,uint256,string)
+    fun create_evm_input(denom: &String, amount: u64, receiver: &String): String {
+        let denom_bytes = pad_zero(*string::bytes(denom));
+        let denom_bytes_len = vector::length(&denom_bytes);
+        let receiver_bytes = pad_zero(*string::bytes(receiver));
+
+        let hex_input = vector[0xbe, 0xed, 0x09, 0x35]; // selector: keccak256(b"minitswapHook(string,uint256,string")).slice(0, 4)
+        vector::append(&mut hex_input, table_key::encode_u256(0x60)); // start position of denom: padded(0x60)
+        vector::append(&mut hex_input, table_key::encode_u256((amount as u256)));
+        vector::append(
+            &mut hex_input, table_key::encode_u256((0x60 + 32 + denom_bytes_len as u256))
+        ); // start position of receiver
+        vector::append(
+            &mut hex_input,
+            table_key::encode_u256((string::length(denom) as u256))
+        ); // denom length
+        vector::append(&mut hex_input, denom_bytes); // denom bytes
+        vector::append(
+            &mut hex_input,
+            table_key::encode_u256((string::length(receiver) as u256))
+        ); // receiver length
+        vector::append(&mut hex_input, receiver_bytes); // receiver bytes
+
+        return to_string(&hex_input)
+    }
+
+    fun pad_zero(data: vector<u8>): vector<u8> {
+        let padding = vector[
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0
+        ];
+        let pad_len = 32 - vector::length(&data) % 32;
+        if (pad_len == 32) {
+            return data
+        };
+
+        vector::trim_reverse(&mut padding, pad_len);
+        vector::append(&mut data, padding);
+        return data
+    }
+
+    struct FinalizeTokenWithdrawalRequest has copy, drop {
+        _type_: String,
+        bridge_id: u64,
+        output_index: u64,
+        withdrawal_proofs: vector<String>,
+        sender: String,
+        receiver: String,
+        sequence: u64,
+        amount: CosmosCoin,
+        version: String,
+        state_root: String,
+        storage_root: String,
+        latest_block_hash: String
+    }
+
+    struct CosmosCoin has copy, drop {
+        denom: String,
+        amount: u64
+    }
+
+    fun generate_finalize_token_withdrawal_msg(
+        bridge_id: u64,
+        output_index: u64,
+        withdrawal_proofs: vector<String>,
+        sender: address,
+        receiver: address,
+        sequence: u64,
+        denom: String,
+        amount: u64,
+        version: String,
+        state_root: String,
+        storage_root: String,
+        latest_block_hash: String
+    ): vector<u8> {
+        json::marshal(
+            &FinalizeTokenWithdrawalRequest {
+                _type_: string::utf8(b"/opinit.ophost.v1.MsgFinalizeTokenWithdrawal"),
+                bridge_id,
+                output_index,
+                withdrawal_proofs,
+                sender: to_sdk(sender),
+                receiver: to_sdk(receiver),
+                sequence,
+                amount: CosmosCoin { denom, amount },
+                version,
+                state_root,
+                storage_root,
+                latest_block_hash
+            }
+        )
+    }
+
+    fun init_metadata(): Object<Metadata> {
+        let addr = object::create_object_address(&@initia_std, b"uinit");
+        object::address_to_object<Metadata>(addr)
+    }
+
+    fun share_token_metadata(): Object<Metadata> {
+        let addr = object::create_object_address(&@initia_std, SYMBOL);
+        object::address_to_object<Metadata>(addr)
+    }
+
+    fun total_share(): u64 {
+        let supply = fungible_asset::supply(share_token_metadata());
+        (*option::borrow(&supply) as u64)
+    }
+
+    fun assert_is_chain(account: &signer, allow_admin: bool) acquires ModuleStore {
+        let addr = signer::address_of(account);
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+        assert!(
+            addr == @initia_std || (allow_admin && module_store.admin == addr),
+            error::permission_denied(EUNAUTHORIZED)
+        );
+    }
+
+    fun generate_unbond_key(account: address, release_time: u64): vector<u8> {
+        let key = bcs::to_bytes(&account);
+        vector::append(&mut key, table_key::encode_u64(release_time));
+        key
+    }
+
+    fun get_ibc_denom(channel_id: String, denom: String): String {
+        let trace = string::utf8(b"transfer/");
+        string::append(&mut trace, channel_id);
+        string::append(&mut trace, string::utf8(b"/"));
+        string::append(&mut trace, denom);
+        let hash = sha2_256(*string::bytes(&trace));
+
+        let denom = string::utf8(b"ibc/");
+        string::append(
+            &mut denom,
+            hex::encode_to_string_with_option(&hash, true)
+        );
+        denom
+    }
+
+    fun get_op_denom(op_bridge_id: u64, denom: String): String {
+        let bytes = table_key::encode_u64(op_bridge_id);
+        vector::append(&mut bytes, *string::bytes(&denom));
+        let hash = sha3_256(bytes);
+
+        let denom = string::utf8(b"l2/");
+        string::append(&mut denom, hex::encode_to_string(&hash));
+        denom
+    }
+
+    fun check_bridge_info(
+        op_bridge_id: u64, ibc_channel: String, ibc_op_init_metadata: Object<Metadata>
+    ): (String, String) {
+        let op_denom = get_op_denom(op_bridge_id, string::utf8(b"uinit"));
+        let ibc_denom = get_ibc_denom(ibc_channel, op_denom);
+        let ibc_token_address =
+            object::create_object_address(&@initia_std, *string::bytes(&ibc_denom));
+        assert!(
+            object::object_address(&ibc_op_init_metadata) == ibc_token_address,
+            error::invalid_argument(EINVAILD_METADATA)
+        );
+
+        (op_denom, ibc_denom)
+    }
+
+    fun mul_div(a: u64, b: u64, c: u64): u64 {
+        let a = (a as u128);
+        let b = (b as u128);
+        let c = (c as u128);
+        (a * b / c as u64)
+    }
+
+    fun is_init(init: &FungibleAsset): bool {
+        let fa_metadata = fungible_asset::metadata_from_asset(init);
+        is_init_metadata(fa_metadata)
+    }
+
+    fun is_init_metadata(metadata: Object<Metadata>): bool {
+        metadata == init_metadata()
+    }
+
+    fun get_d0(pool_size: u64, ann: u64): u64 {
+        get_d(pool_size, pool_size, ann)
+    }
+
+    fun get_d(init_amount: u64, ibc_op_init_amount: u64, ann: u64): u64 {
+        let init_amount = (init_amount as u256);
+        let ibc_op_init_amount = (ibc_op_init_amount as u256);
+        let ann = (ann as u256);
+
+        let sum = init_amount + ibc_op_init_amount;
+        if (sum == 0) return 0;
+        let d = sum;
+
+        let i = 0;
+
+        // converge
+        // d = (ann * sum - d_prod) / (ann - 1)
+        while (i < 255) {
+            let d_prev = d;
+            // D ** (n + 1) / (n ** n * prod) in our case, always n = 2
+            let d_prod = d * d * d / 4 / init_amount / ibc_op_init_amount;
+
+            d = (ann * sum / A_PRECISION + d_prod * 2) * d
+                / ((ann - A_PRECISION) * d / A_PRECISION + 3 * d_prod);
+            if (d > d_prev) {
+                if (d - d_prev <= 1) break
+            } else {
+                if (d_prev - d <= 1) break
+            };
+            i = i + 1;
+        };
+
+        return (d as u64)
+    }
+
+    fun get_return_amount(
+        offer_amount: u64,
+        offer_pool_amount: u64,
+        return_pool_amount: u64,
+        pool_size: u64,
+        ann: u64
+    ): u64 {
+        if (offer_amount == 0) {
+            return 0
+        };
+
+        let d = get_d0(pool_size, ann);
+        let offer_pool_amount_after = offer_pool_amount + offer_amount;
+
+        let y = get_y(d, offer_pool_amount_after, ann);
+
+        (return_pool_amount - y as u64)
+    }
+
+    fun get_offer_amount(
+        return_amount: u64,
+        offer_pool_amount: u64,
+        return_pool_amount: u64,
+        pool_size: u64,
+        ann: u64
+    ): u64 {
+        if (return_amount == 0) {
+            return 0
+        };
+
+        let d = get_d0(pool_size, ann);
+        let return_pool_amount_after = return_pool_amount - return_amount;
+
+        let y = get_y(d, return_pool_amount_after, ann);
+
+        (y - offer_pool_amount as u64)
+    }
+
+    /// get counterparty's amount
+    fun get_y(d: u64, x: u64, ann: u64): u64 {
+        let d = (d as u256);
+        let x = (x as u256);
+        let ann = (ann as u256);
+
+        // Done by solving quadratic equation iteratively.
+        // x_1**2 + x_1 * (sum' - (A*n**n - 1) * D / (A * n**n)) = D ** (n + 1) / (n ** (2 * n) * prod' * A)
+        // y**2 + y * (x - (A * 2**2 - 1) * D / (A * 2**2)) = D ** (2 + 1) / (2 ** (2 * 2) * x * A)
+        // y**2 + b*y = c
+
+        // y = (y**2 + c) / (2*y + b)
+
+        let c = d * d * d * A_PRECISION / ann / 4 / x; // d ** (2 + 1) / ann / 2 ** 2 / x
+        let b_plus_d = x + d * A_PRECISION / ann; // need to sub d but sub later due to value must be less than 0
+
+        let y_prev;
+        let y = d;
+
+        let i = 0;
+        // converge
+        while (i < 255) {
+            y_prev = y;
+            y = (y * y + c) / (2 * y + b_plus_d - d); // sub d here
+
+            if (y > y_prev) {
+                if (y - y_prev <= 1) break
+            } else {
+                if (y_prev - y <= 1) break
+            };
+            i = i + 1;
+        };
+
+        (y as u64)
+    }
+
+    // R_fr = 0.5 + (R_max - 0.5) * (f * I) ** 3 / (1 + (f * I) ** 3)
+    fun get_fully_recovered_ratio(
+        imbalance: BigDecimal, max_ratio: BigDecimal, recover_param: BigDecimal
+    ): BigDecimal {
+        let fi = bigdecimal::mul(recover_param, imbalance);
+        let fi3 = bigdecimal::mul(fi, bigdecimal::mul(fi, fi));
+        let half = bigdecimal::from_ratio_u64(1, 2); // .5
+        let to_sum =
+            bigdecimal::mul(
+                bigdecimal::sub(max_ratio, half), // R_max - 0.5
+                bigdecimal::div(fi3, bigdecimal::add(bigdecimal::one(), fi3))
+                // (f * I) ** 3 / (1 + (f * I) ** 3)
+            );
+
+        bigdecimal::add(half, to_sum)
+    }
+
+    fun get_fully_recovered_pool_amounts(
+        pool_size: u64, fully_recovered_ratio: BigDecimal, ann: u64
+    ): (u64, u64) {
+        let one = bigdecimal::one();
+        let g =
+            bigdecimal::div(
+                fully_recovered_ratio, bigdecimal::sub(one, fully_recovered_ratio)
+            );
+        let z = pool_size;
+
+        // Get first point
+        let d0 = get_d0(pool_size, ann);
+        let x =
+            bigdecimal::truncate_u64(
+                bigdecimal::div(
+                    bigdecimal::mul_by_u64(bigdecimal::from_u64(z), 2),
+                    bigdecimal::add(g, one)
+                )
+            ); // x = 2z / (g + 1)
+        if (x == z) { // fully_recovered_ratio = 0.5
+            return (pool_size, pool_size)
+        };
+        let y = get_y(d0, (x as u64), ann);
+
+        let i = 0;
+        let x_prev;
+        // get the cross point of y = grad * x and [(pool_size, pool_size), (x_prev, y_prev)]
+        // the point is (temp_x, y), get x from y
+        while (i < 255) {
+            x_prev = x;
+            // get cross point of y = g * x and y - y' = [(z - y') / (z - x')](x - x')
+            // x = z * (x' - y') / (g * (x'- z) - (y' - z))
+            // x = z * (y' - x') / (g * (z - x') + (y' - z))
+            let temp_x =
+                bigdecimal::div(
+                    bigdecimal::mul_by_u64(bigdecimal::from_u64(z), y - x),
+                    bigdecimal::add_by_u64(bigdecimal::mul_by_u64(g, z - x), y - z)
+                );
+
+            // get y from temp x
+            y = bigdecimal::truncate_u64(bigdecimal::mul(g, temp_x));
+            // get x from y
+            x = get_y(d0, y, ann);
+
+            // when fully recovered rate is too close to 0.5 y can be same with pool_size
+            if (y == z) break;
+
+            // when fully recovered rate is too close to 0.5 x can be slightly higher than pool_size
+            if (x > z) {
+                x = pool_size;
+                break
+            };
+
+            if (x >= x_prev) {
+                if (x - x_prev <= 1) break
+            } else {
+                if (x_prev - x <= 1) break
+            };
+            i = i + 1;
+        };
+
+        ((x as u64), (y as u64))
+    }
+
+    fun assert_min_amount(fa: &FungibleAsset, min_return: Option<u64>) {
+        if (option::is_some(&min_return)) {
+            let amount = fungible_asset::amount(fa);
+            assert!(
+                amount >= option::extract(&mut min_return),
+                error::invalid_state(EMIN_RETURN)
+            )
+        }
+    }
+
+    // swap simulation that not returning error
+    public fun safe_swap_simulation(
+        offer_metadata: Object<Metadata>,
+        return_metadata: Object<Metadata>,
+        offer_amount: u64
+    ): (u64, u64) acquires ModuleStore, VirtualPool {
+        let is_init_offered = is_init_metadata(offer_metadata);
+        let ibc_op_init_metadata =
+            if (is_init_offered) {
+                return_metadata
+            } else {
+                offer_metadata
+            };
+
+        let virtual_pool_exists = virtual_pool_exists(ibc_op_init_metadata);
+
+        assert!(
+            virtual_pool_exists,
+            error::invalid_argument(EPOOL_NOT_FOUND)
+        );
+
+        let (init_pool_amount, ibc_op_init_pool_amount) =
+            get_pool_amount(ibc_op_init_metadata, !is_init_offered);
+        let (module_store, pool) = borrow_all(ibc_op_init_metadata);
+        let (pool_size, ann) = (pool.pool_size, pool.ann);
+        let (return_amount, fee_amount) =
+            if (is_init_offered) {
+                let return_amount =
+                    get_return_amount(
+                        offer_amount,
+                        init_pool_amount,
+                        ibc_op_init_pool_amount,
+                        pool_size,
+                        ann
+                    );
+
+                if (ibc_op_init_pool_amount - return_amount < pool_size) {
+                    return (0, 0)
+                };
+
+                // take swap fee
+                let swap_fee_amount =
+                    bigdecimal::mul_by_u64_ceil(
+                        module_store.swap_fee_rate, return_amount
+                    );
+
+                // take arb fee
+                let arb_profit =
+                    if (return_amount > offer_amount + swap_fee_amount) {
+                        return_amount - swap_fee_amount - offer_amount
+                    } else { 0 };
+                let arb_fee_amount =
+                    bigdecimal::mul_by_u64_ceil(module_store.arb_fee_rate, arb_profit);
+                let fee_amount = swap_fee_amount + arb_fee_amount;
+
+                (return_amount, fee_amount)
+            } else {
+                let return_amount =
+                    get_return_amount(
+                        offer_amount,
+                        ibc_op_init_pool_amount,
+                        init_pool_amount,
+                        pool_size,
+                        ann
+                    );
+                let fee_amount =
+                    bigdecimal::mul_by_u64_ceil(
+                        module_store.swap_fee_rate, return_amount
+                    );
+
+                (return_amount, fee_amount)
+            };
+
+        return_amount = return_amount - fee_amount;
+
+        (return_amount, fee_amount)
+    }
+
+    public fun safe_swap_simulation_given_out(
+        offer_metadata: Object<Metadata>,
+        return_metadata: Object<Metadata>,
+        return_amount: u64
+    ): (u64, u64) acquires ModuleStore, VirtualPool {
+        let is_init_offered = is_init_metadata(offer_metadata);
+        let ibc_op_init_metadata =
+            if (is_init_offered) {
+                return_metadata
+            } else {
+                offer_metadata
+            };
+
+        let virtual_pool_exists = virtual_pool_exists(ibc_op_init_metadata);
+
+        assert!(
+            virtual_pool_exists,
+            error::invalid_argument(EPOOL_NOT_FOUND)
+        );
+
+        let (init_pool_amount, ibc_op_init_pool_amount) =
+            get_pool_amount(ibc_op_init_metadata, !is_init_offered);
+        let (module_store, pool) = borrow_all(ibc_op_init_metadata);
+        let (pool_size, ann) = (pool.pool_size, pool.ann);
+        let (offer_amount, fee_amount) =
+            if (is_init_offered) {
+                // first assume there are no arb fee and calculate offer amount
+                // and then calculate arb fee and get actual return amount which is same with return_amount_before_swap_fee - swap_fee_amount - arb_fee_amount
+                // to make actual return amount to return amount, set return_amount_before_swap_fee = return_amount_before_swap_fee + return_diff
+                // where return_diff = target return amount - actual return amount
+                // and recalculate offer amount repeatedly until return amount <= actual return amount
+                // note that actual return is always small or equal with target return amount
+
+                // adjust fee. return amount before swap fee = return amount * 1 / (1 - f)
+                let return_amount_before_swap_fee =
+                    bigdecimal::truncate_u64(
+                        bigdecimal::div(
+                            bigdecimal::from_u64(return_amount),
+                            bigdecimal::sub(
+                                bigdecimal::one(), module_store.swap_fee_rate
+                            )
+                        )
+                    );
+                if (ibc_op_init_pool_amount - return_amount_before_swap_fee < pool_size) {
+                    return ((U64_MAX as u64), (U64_MAX as u64))
+                };
+
+                let swap_fee_amount = return_amount_before_swap_fee - return_amount;
+
+                let offer_amount =
+                    get_offer_amount(
+                        return_amount_before_swap_fee,
+                        init_pool_amount,
+                        ibc_op_init_pool_amount,
+                        pool_size,
+                        ann
+                    );
+
+                // calculate arb fee
+                let arb_profit =
+                    if (return_amount > offer_amount) {
+                        return_amount - offer_amount
+                    } else { 0 };
+                let arb_fee_amount =
+                    bigdecimal::mul_by_u64_ceil(module_store.arb_fee_rate, arb_profit);
+
+                // actual return amount is return amount - arb fee
+                let actual_return_amount = return_amount - arb_fee_amount;
+                let return_diff = arb_fee_amount;
+
+                // retry while actual return amount is equal to return amount
+                let i = 0;
+                while (return_amount > actual_return_amount && i < 255) {
+                    return_amount_before_swap_fee = return_amount_before_swap_fee
+                        + return_diff;
+
+                    if (ibc_op_init_pool_amount - return_amount_before_swap_fee
+                        < pool_size) {
+                        return ((U64_MAX as u64), (U64_MAX as u64))
+                    };
+
+                    swap_fee_amount = bigdecimal::mul_by_u64_ceil(
+                        module_store.swap_fee_rate,
+                        return_amount_before_swap_fee
+                    );
+
+                    offer_amount = get_offer_amount(
+                        return_amount_before_swap_fee,
+                        init_pool_amount,
+                        ibc_op_init_pool_amount,
+                        pool_size,
+                        ann
+                    );
+
+                    // calculate arb fee
+                    arb_profit = if (return_amount > offer_amount) {
+                        return_amount_before_swap_fee - swap_fee_amount - offer_amount
+                    } else { 0 };
+                    arb_fee_amount = bigdecimal::mul_by_u64_ceil(
+                        module_store.arb_fee_rate, arb_profit
+                    );
+                    actual_return_amount = return_amount_before_swap_fee
+                        - swap_fee_amount - arb_fee_amount;
+                    if (actual_return_amount >= return_amount) break;
+
+                    return_diff = return_amount - actual_return_amount;
+                    i = i + 1;
+                };
+
+                (offer_amount, swap_fee_amount + arb_fee_amount)
+            } else {
+                // adjust fee. amount = amount * 1 / (1 - f)
+                let return_amount_ =
+                    bigdecimal::truncate_u64(
+                        bigdecimal::div(
+                            bigdecimal::from_u64(return_amount),
+                            bigdecimal::sub(
+                                bigdecimal::one(), module_store.swap_fee_rate
+                            )
+                        )
+                    );
+                let fee_amount = return_amount_ - return_amount;
+
+                let offer_amount =
+                    get_offer_amount(
+                        return_amount_,
+                        ibc_op_init_pool_amount,
+                        init_pool_amount,
+                        pool_size,
+                        ann
+                    );
+
+                (offer_amount, fee_amount)
+            };
+
+        (offer_amount, fee_amount)
+    }
+
+    #[test_only]
+    public fun init_module_for_test() {
+        init_module(&initia_std::account::create_signer_for_test(@initia_std));
+    }
+
+    #[test_only]
+    fun initialized_coin(
+        account: &signer, symbol: String
+    ): (coin::BurnCapability, coin::FreezeCapability, coin::MintCapability) {
+        let (mint_cap, burn_cap, freeze_cap, _) =
+            coin::initialize_and_generate_extend_ref(
+                account,
+                option::none(),
+                string::utf8(b""),
+                symbol,
+                6,
+                string::utf8(b""),
+                string::utf8(b"")
+            );
+
+        return (burn_cap, freeze_cap, mint_cap)
+    }
+
+    #[test_only]
+    fun finalize_arb_mock(
+        account: &signer,
+        arb_index: u64,
+        _bridge_id: u64,
+        _output_index: u64,
+        _withdrawal_proofs: vector<String>,
+        _sender: address,
+        _sequence: u64,
+        amount: u64,
+        _version: String,
+        _state_root: String,
+        _storage_root: String,
+        _latest_block_hash: String,
+        init_mint_cap: &coin::MintCapability
+    ) acquires ModuleStore, VirtualPool {
+        // check arb info
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+        let pool_obj =
+            table::borrow(
+                &module_store.global_arb_batch_map,
+                table_key::encode_u64(arb_index)
+            );
+        let pool = borrow_global<VirtualPool>(object::object_address(&*pool_obj));
+        let arb_info =
+            table::borrow(
+                &pool.arb_batch_map,
+                table_key::encode_u64(arb_index)
+            );
+
+        assert!(
+            amount == arb_info.ibc_op_init_sent,
+            error::invalid_argument(EAMOUNT_MISMATCH)
+        );
+
+        // mock finalize withdraw
+        coin::mint_to(
+            init_mint_cap,
+            object::address_from_extend_ref(&pool.extend_ref),
+            amount
+        );
+
+        let module_signer =
+            object::generate_signer_for_extending(&module_store.extend_ref);
+
+        // execute hook
+        finalize_arb_hook(
+            &module_signer,
+            arb_index,
+            signer::address_of(account)
+        );
+    }
+
+    #[test]
+    fun test_finalize_token_withdrawal_msg() {
+        let msg =
+            generate_finalize_token_withdrawal_msg(
+                1,
+                2,
+                vector[string::utf8(b"abc"), string::utf8(b"123")],
+                @0x1,
+                @0x2,
+                3,
+                string::utf8(b"uinit"),
+                100,
+                string::utf8(b"version"),
+                string::utf8(b"state_root"),
+                string::utf8(b"storage_root"),
+                string::utf8(b"latest_block_hash")
+            );
+        let json_str =
+            b"{\"@type\":\"/opinit.ophost.v1.MsgFinalizeTokenWithdrawal\",\"amount\":{\"amount\":\"100\",\"denom\":\"uinit\"},\"bridge_id\":\"1\",\"latest_block_hash\":\"latest_block_hash\",\"output_index\":\"2\",\"receiver\":\"init1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqzwsp0lj\",\"sender\":\"init1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpqr5e3d\",\"sequence\":\"3\",\"state_root\":\"state_root\",\"storage_root\":\"storage_root\",\"version\":\"version\",\"withdrawal_proofs\":[\"abc\",\"123\"]}";
+        assert!(msg == json_str, 0);
+    }
+
+    #[test]
+    fun test_ibc_denom() {
+        let ibc_denom =
+            get_ibc_denom(
+                string::utf8(b"channel-0"),
+                string::utf8(
+                    b"l2/771d639f30fbe45e3fbca954ffbe2fcc26f915f5513c67a4a2d0bc1d635bdefd"
+                )
+            );
+        assert!(
+            string::utf8(
+                b"ibc/82EB1C694C571F954E68BFD68CFCFCD6123B0EBB69AAA8BAB7A082939B45E802"
+            ) == ibc_denom,
+            0
+        );
+    }
+
+    #[test]
+    fun test_op_denom() {
+        let op_denom = get_op_denom(1, string::utf8(b"uinit"));
+        assert!(
+            string::utf8(
+                b"l2/771d639f30fbe45e3fbca954ffbe2fcc26f915f5513c67a4a2d0bc1d635bdefd"
+            ) == op_denom,
+            0
+        );
+    }
+
+    #[test(chain = @0x1)]
+    fun in_house_arb_test(chain: signer) acquires ModuleStore, VirtualPool {
+        initia_std::primary_fungible_store::init_module_for_test();
+        init_module(&chain);
+        block::set_block_info(0, 100);
+        let chain_addr = signer::address_of(&chain);
+
+        let (_, _, initia_mint_cap) = initialized_coin(&chain, string::utf8(b"uinit"));
+        let (_, _, ibc_op_init_mint_cap) =
+            initialized_coin(
+                &chain,
+                string::utf8(
+                    b"ibc/82EB1C694C571F954E68BFD68CFCFCD6123B0EBB69AAA8BAB7A082939B45E802"
+                )
+            );
+        let init_metadata = coin::metadata(chain_addr, string::utf8(b"uinit"));
+        let ibc_op_init_metadata =
+            coin::metadata(
+                chain_addr,
+                string::utf8(
+                    b"ibc/82EB1C694C571F954E68BFD68CFCFCD6123B0EBB69AAA8BAB7A082939B45E802"
+                )
+            );
+        coin::mint_to(&initia_mint_cap, chain_addr, 1000000000);
+        coin::mint_to(&ibc_op_init_mint_cap, chain_addr, 1000000000);
+        provide(&chain, 15000000, option::none());
+
+        create_pool(
+            &chain,
+            ibc_op_init_metadata,
+            bigdecimal::from_ratio_u64(100000, 1),
+            10000000,
+            3000,
+            bigdecimal::from_ratio_u64(7, 10),
+            bigdecimal::from_ratio_u64(2, 1),
+            MOVE,
+            string::utf8(b"0x1"),
+            1,
+            string::utf8(b"channel-0")
+        );
+
+        swap(
+            &chain,
+            ibc_op_init_metadata,
+            init_metadata,
+            10000000,
+            option::none()
+        );
+
+        block::set_block_info(0, 100000);
+
+        // trigger check arb
+        swap(
+            &chain,
+            ibc_op_init_metadata,
+            init_metadata,
+            10000000,
+            option::none()
+        );
+
+        let arb_info = get_arb_info(0);
+
+        // finalize arb
+        let str = string::utf8(b"");
+        let excutor_balance_before = coin::balance(@0x1, init_metadata);
+
+        finalize_arb_mock(
+            &chain,
+            0,
+            1,
+            1,
+            vector[],
+            @0x1,
+            1,
+            arb_info.ibc_op_init_sent,
+            str,
+            str,
+            str,
+            str,
+            &initia_mint_cap
+        );
+
+        let excutor_balance_after = coin::balance(@0x1, init_metadata);
+
+        // check triggering fee
+        assert!(
+            excutor_balance_after - excutor_balance_before == arb_info.triggering_fee,
+            0
+        );
+    }
+
+    #[test(chain = @0x1)]
+    fun end_to_end(chain: signer) acquires ModuleStore, VirtualPool {
+        initia_std::primary_fungible_store::init_module_for_test();
+        init_module(&chain);
+        stableswap::init_module_for_test();
+
+        block::set_block_info(0, 100);
+
+        let chain_addr = signer::address_of(&chain);
+
+        let (_, _, initia_mint_cap) = initialized_coin(&chain, string::utf8(b"uinit"));
+        let (_, _, ibc_op_init_1_mint_cap) =
+            initialized_coin(
+                &chain,
+                string::utf8(
+                    b"ibc/82EB1C694C571F954E68BFD68CFCFCD6123B0EBB69AAA8BAB7A082939B45E802"
+                )
+            );
+        let (_, _, ibc_op_init_2_mint_cap) =
+            initialized_coin(
+                &chain,
+                string::utf8(
+                    b"ibc/AD8D520BF2D981113B652A3BCD55368EF146FCB9E016F8B1DAECAA5D570BC8A1"
+                )
+            );
+        let init_metadata = coin::metadata(chain_addr, string::utf8(b"uinit"));
+        let ibc_op_init_1_metadata =
+            coin::metadata(
+                chain_addr,
+                string::utf8(
+                    b"ibc/82EB1C694C571F954E68BFD68CFCFCD6123B0EBB69AAA8BAB7A082939B45E802"
+                )
+            );
+        let ibc_op_init_2_metadata =
+            coin::metadata(
+                chain_addr,
+                string::utf8(
+                    b"ibc/AD8D520BF2D981113B652A3BCD55368EF146FCB9E016F8B1DAECAA5D570BC8A1"
+                )
+            );
+
+        coin::mint_to(&initia_mint_cap, chain_addr, 100000000);
+        coin::mint_to(
+            &ibc_op_init_1_mint_cap,
+            chain_addr,
+            1000000000
+        );
+        coin::mint_to(
+            &ibc_op_init_2_mint_cap,
+            chain_addr,
+            1000000000
+        );
+        provide(&chain, 15000000, option::none());
+
+        create_pool(
+            &chain,
+            ibc_op_init_1_metadata,
+            bigdecimal::from_ratio_u64(100000, 1),
+            10000000,
+            3000,
+            bigdecimal::from_ratio_u64(7, 10),
+            bigdecimal::from_ratio_u64(2, 1),
+            MOVE,
+            string::utf8(b"0x1"),
+            1,
+            string::utf8(b"channel-0")
+        );
+
+        create_pool(
+            &chain,
+            ibc_op_init_2_metadata,
+            bigdecimal::from_ratio_u64(100000, 1),
+            10000000,
+            3000,
+            bigdecimal::from_ratio_u64(7, 10),
+            bigdecimal::from_ratio_u64(2, 1),
+            MOVE,
+            string::utf8(b"0x1"),
+            2,
+            string::utf8(b"channel-2")
+        );
+
+        create_stableswap_pool(
+            &chain,
+            1,
+            string::utf8(b"channel-0"),
+            ibc_op_init_1_metadata,
+            10000000,
+            10000000
+        );
+
+        // swap ibc op init to init
+        let (return_amount, _) =
+            swap_simulation(
+                ibc_op_init_1_metadata,
+                init_metadata,
+                1000000
+            );
+        assert!(return_amount == 992740, 0);
+
+        let balance_before = coin::balance(chain_addr, init_metadata);
+        swap(
+            &chain,
+            ibc_op_init_1_metadata,
+            init_metadata,
+            1000000,
+            option::none()
+        );
+        let balance_after = coin::balance(chain_addr, init_metadata);
+        assert!(
+            balance_after - balance_before == return_amount,
+            0
+        );
+
+        // swap init to ibc op init
+        let (return_amount, _) =
+            swap_simulation(init_metadata, ibc_op_init_1_metadata, 500000);
+        assert!(return_amount == 504224, 0);
+
+        let balance_before = coin::balance(chain_addr, ibc_op_init_1_metadata);
+        swap(
+            &chain,
+            init_metadata,
+            ibc_op_init_1_metadata,
+            500000,
+            option::none()
+        );
+        let balance_after = coin::balance(chain_addr, ibc_op_init_1_metadata);
+        assert!(
+            balance_after - balance_before == return_amount,
+            0
+        );
+
+        change_pool_size(&chain, ibc_op_init_1_metadata, 9000000);
+    }
+
+    #[test]
+    fun test_generate_ibc_message() {
+        let (ibc_receiver, memo) =
+            generate_ibc_message(
+                MOVE,
+                string::utf8(b"0x1"),
+                1,
+                string::utf8(b"receiver"),
+                string::utf8(b"op_denom"),
+                1000000
+            );
+
+        assert!(ibc_receiver == string::utf8(b"0x1::minitswap_hook::minitswap_hook"), 0);
+        assert!(
+            memo
+                == string::utf8(
+                    b"{\"evm\":null,\"move\":{\"async_callback\":{\"id\":\"1\",\"module_address\":\"0x1\",\"module_name\":\"minitswap\"},\"message\":{\"args\":[\"CG9wX2Rlbm9t\",\"QEIPAAAAAAA=\",\"CHJlY2VpdmVy\"],\"function_name\":\"minitswap_hook\",\"module_address\":\"0x1\",\"module_name\":\"minitswap_hook\",\"type_args\":[]}},\"wasm\":null}"
+                ),
+            1
+        );
+
+        let (ibc_receiver, memo) =
+            generate_ibc_message(
+                COSMWASM,
+                string::utf8(b"cosmwasm_contract_addr"),
+                1,
+                string::utf8(b"receiver"),
+                string::utf8(b"op_denom"),
+                1000000
+            );
+
+        assert!(ibc_receiver == string::utf8(b"cosmwasm_contract_addr"), 2);
+        assert!(
+            memo
+                == string::utf8(
+                    b"{\"evm\":null,\"move\":{\"async_callback\":{\"id\":\"1\",\"module_address\":\"0x1\",\"module_name\":\"minitswap\"},\"message\":null},\"wasm\":{\"message\":{\"contracts\":\"cosmwasm_contract_addr\",\"funds\":[{\"amount\":\"1000000\",\"denom\":\"op_denom\"}],\"msg\":{\"minitswap_hook\":{\"receiver\":\"receiver\"}}}}}"
+                ),
+            3
+        );
+    }
+
+    #[test]
+    fun test_evm_input() {
+        assert!(
+            create_evm_input(
+                &string::utf8(
+                    b"l2/771d639f30fbe45e3fbca954ffbe2fcc26f915f5513c67a4a2d0bc1d635bdefd"
+                ),
+                100,
+                &string::utf8(b"init1lf0swvvhy3vqautdemmvunfmp0grfrjgzznx9s")
+            ) == string::utf8(
+                b"0xbeed09350000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000006400000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000436c322f373731643633396633306662653435653366626361393534666662653266636332366639313566353531336336376134613264306263316436333562646566640000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002b696e6974316c663073777676687933767161757464656d6d76756e666d7030677266726a677a7a6e783973000000000000000000000000000000000000000000"
+            ),
+            0
+        )
+    }
+}