1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! # Decentralized Exchange Api
//!
//! `abstract_os::dex` is a generic dex-interfacing contract that handles address retrievals and dex-interactions.

use crate::{
    api::{self},
    objects::{AnsAsset, AssetEntry, DexAssetPairing},
};
use cosmwasm_schema::QueryResponses;
use cosmwasm_std::{Decimal, Uint128};

pub type DexName = String;
pub type OfferAsset = AnsAsset;
pub type AskAsset = AnsAsset;

pub mod state {
    use cw_storage_plus::Item;

    use crate::objects::fee::UsageFee;

    pub const SWAP_FEE: Item<UsageFee> = Item::new("swap_fee");
}

pub const IBC_DEX_ID: u32 = 11335;

pub type ExecuteMsg = api::ExecuteMsg<DexApiExecuteMsg>;
pub type QueryMsg = api::QueryMsg<DexQueryMsg>;
pub type InstantiateMsg = api::InstantiateMsg<DexInstantiateMsg>;

impl api::ApiExecuteMsg for DexApiExecuteMsg {}
impl api::ApiQueryMsg for DexQueryMsg {}

#[cosmwasm_schema::cw_serde]
pub struct DexInstantiateMsg {
    pub swap_fee: Decimal,
    pub recipient_os: u32,
}

/// Dex Execute msg
#[cosmwasm_schema::cw_serde]
pub enum DexApiExecuteMsg {
    Action(DexExecuteMsg),
    UpdateFee {
        swap_fee: Option<Decimal>,
        recipient_os_id: Option<u32>,
    },
}

impl From<DexExecuteMsg> for DexApiExecuteMsg {
    fn from(action: DexExecuteMsg) -> Self {
        DexApiExecuteMsg::Action(action)
    }
}

/// Dex Execute msg
#[cosmwasm_schema::cw_serde]
pub struct DexExecuteMsg {
    pub dex: DexName,
    pub action: DexAction,
}

#[cosmwasm_schema::cw_serde]
/// Possible actions to perform on the DEX
pub enum DexAction {
    /// Provide arbitrary liquidity
    ProvideLiquidity {
        // support complex pool types
        /// Assets to add
        assets: Vec<OfferAsset>,
        max_spread: Option<Decimal>,
    },
    /// Provide liquidity equally between assets to a pool
    ProvideLiquiditySymmetric {
        offer_asset: OfferAsset,
        // support complex pool types
        /// Assets that are paired with the offered asset
        paired_assets: Vec<AssetEntry>,
    },
    /// Withdraw liquidity from a pool
    WithdrawLiquidity {
        lp_token: AssetEntry,
        amount: Uint128,
    },
    /// Standard swap between one asset to another
    Swap {
        offer_asset: OfferAsset,
        ask_asset: AssetEntry,
        max_spread: Option<Decimal>,
        belief_price: Option<Decimal>,
    },
    /// Allow alternative swap routers and methods
    CustomSwap {
        offer_assets: Vec<OfferAsset>,
        ask_assets: Vec<AskAsset>,
        max_spread: Option<Decimal>,
        /// Optionally supply a router to use
        router: Option<SwapRouter>,
    },
}

#[cosmwasm_schema::cw_serde]
pub enum SwapRouter {
    /// Matrix router
    Matrix,
    /// Use a custom router (using String type for cross-chain compatibility)
    Custom(String),
}

#[cosmwasm_schema::cw_serde]
#[derive(QueryResponses)]
#[cfg_attr(feature = "boot", derive(boot_core::QueryFns))]
#[cfg_attr(feature = "boot", impl_into(QueryMsg))]
pub enum DexQueryMsg {
    #[returns(SimulateSwapResponse)]
    SimulateSwap {
        offer_asset: OfferAsset,
        ask_asset: AssetEntry,
        dex: Option<DexName>,
    },
}

// LP/protocol fees could be withheld from either input or output so commission asset must be included.
#[cosmwasm_schema::cw_serde]
pub struct SimulateSwapResponse {
    pub pool: DexAssetPairing,
    /// Amount you would receive when performing the swap.
    pub return_amount: Uint128,
    /// Spread in ask_asset for this swap
    pub spread_amount: Uint128,
    /// Commission charged for the swap
    pub commission: (AssetEntry, Uint128),
    /// API fee charged for the swap (paid in offer asset)
    pub api_fee: Uint128,
}