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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

use cosmwasm_std::{Coin, CosmosMsg};
use injective_cosmwasm::{InjectiveMsgWrapper, SubaccountId};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use serde_cw_value::Value;

use crate::vault::{AmmRedeemSubscribeMsg, InstantiateVaultMsg, RedemptionType, Slippage, Vault};

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
pub struct InstantiateMsg {
    pub owner: String,
    pub distribution_contract: String, // collected rewards receiver
    pub mito_token: String,
    pub is_allowing_open_registrations: bool,
    pub is_opting_out_rewards: bool,
    pub permissionless_vault_registration_fee: Vec<Coin>,
    pub min_permissionless_vault_initial_funds: Vec<Coin>,
    pub mito_treasury_address: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
pub struct InjectiveForwardExec {
    pub vault_subaccount_id: SubaccountId,
    pub trader_subaccount_id: SubaccountId,
    pub msg: Value,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
pub struct AmmInjectiveForwardExec {
    pub vault_subaccount_id: SubaccountId,
    pub trader_subaccount_id: SubaccountId,
    pub msg: AmmRedeemSubscribeMsg,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
#[allow(clippy::large_enum_variant)]
pub enum MasterAmmExecuteMsg {
    InjectiveExec {
        origin: String,
        name: String,
        args: AmmInjectiveForwardExec,
    },
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub struct PermissionlessInfo {
    pub whitelisted_vault_code_id: u64,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub struct RestrictedInfo {
    pub vault_code_id: u64,
    pub vault_upgrade_admin: Option<String>, // None means immutable
    pub vault_label: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum RegistrationMode {
    Permissionless(PermissionlessInfo),
    Restricted(RestrictedInfo),
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
#[allow(clippy::large_enum_variant)]
pub enum ExecuteMsg {
    InjectiveExec {
        origin: String,
        name: String,
        args: InjectiveForwardExec,
    },
    AddAllowedVaultRegistrationAddress {
        address: String,
    },
    RemoveAllowedVaultRegistrationAddress {
        address: String,
    },
    AddOneTimeAllowedVaultRegistrationAddress {
        address: String,
        code_id: u64,
    },
    AddCodeIdToWhitelist {
        code_id: u64,
    },
    RemoveCodeIdFromWhitelist {
        code_id: u64,
    },
    UpdateConfig {
        owner: Option<String>,
        distribution_contract: Option<String>,
        is_allowing_open_registrations: Option<bool>,
        permissionless_vault_registration_fee: Option<Vec<Coin>>,
        min_permissionless_vault_initial_funds: Option<Vec<Coin>>,
        mito_treasury_address: Option<String>,
    },
    ExecuteMessagesForVault {
        injective_messages: Vec<CosmosMsg<InjectiveMsgWrapper>>,
    },
    RegisterVault {
        registration_mode: RegistrationMode,
        instantiate_vault_msg: InstantiateVaultMsg,
        is_subscribing_with_funds: bool,
    },
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
    Config {},
    GetLastRegisteredVault {},
    HasOneTimeAllowance {
        user_address: String,
        code_id: u64,
    },
    GetRegisteredVaults {
        start_after_vault_addr: Option<String>,
        start_after_subaccount: Option<SubaccountId>,
        limit: Option<u32>,
    },
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
pub struct RegisteredVault {
    pub vault: Vault,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
pub struct RegisteredVaultsResponse {
    pub registered_vaults: Vec<RegisteredVault>,
}

// We define a custom struct for each query response
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
pub struct ConfigResponse {
    pub owner: String,
    pub distribution_contract: String, // collected rewards receiver
    pub mito_token: String,
    pub mito_treasury_address: String,
    pub is_allowing_open_registrations: bool,
    pub permissionless_vault_registration_fee: Vec<Coin>,
    pub min_permissionless_vault_initial_funds: Vec<Coin>,
    pub version: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
pub struct VaultSubscribeArgs {
    pub vault_subaccount_id: SubaccountId,
    pub subscriber_subaccount_id: SubaccountId,
    pub slippage: Option<Slippage>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
pub struct VaultRedeemArgs {
    pub vault_subaccount_id: SubaccountId,
    pub redeemer_subaccount_id: SubaccountId,
    pub redemption_type: RedemptionType,
    pub slippage: Option<Slippage>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
pub enum VaultInputArgs {
    Subscribe { args: VaultSubscribeArgs },
    Redeem { args: VaultRedeemArgs },
}