hpl-interface 0.0.6

Interface definitions for CosmWasm Hyperlane contracts
Documentation 
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
169
170
171

use cosmwasm_schema::{cw_serde, QueryResponses};
use cosmwasm_std::{Addr, HexBinary, Uint256};

use crate::{
    hook::{HookQueryMsg, PostDispatchMsg},
    ownable::{OwnableMsg, OwnableQueryMsg},
    router::{RouterMsg, RouterQuery},
    Order,
};

use super::oracle::IgpGasOracleQueryMsg;

#[cw_serde]
pub struct InstantiateMsg {
    pub hrp: String,
    pub owner: String,
    pub gas_token: String,
    pub beneficiary: String,
    pub default_gas_usage: u128,
}

#[cw_serde]
pub struct GasOracleConfig {
    pub remote_domain: u32,
    pub gas_oracle: String,
}

impl From<(u32, String)> for GasOracleConfig {
    fn from((remote_domain, gas_oracle): (u32, String)) -> Self {
        Self {
            remote_domain,
            gas_oracle,
        }
    }
}

impl From<(u32, Addr)> for GasOracleConfig {
    fn from((remote_domain, gas_oracle): (u32, Addr)) -> Self {
        Self {
            remote_domain,
            gas_oracle: gas_oracle.to_string(),
        }
    }
}

#[cw_serde]
pub enum ExecuteMsg {
    // overrides
    Ownable(OwnableMsg),
    Router(RouterMsg<Addr>),
    PostDispatch(PostDispatchMsg),

    // base
    SetDefaultGas {
        gas: u128,
    },
    SetGasForDomain {
        config: Vec<(u32, u128)>,
    },
    UnsetGasForDomain {
        domains: Vec<u32>,
    },

    SetBeneficiary {
        beneficiary: String,
    },
    PayForGas {
        message_id: HexBinary,
        dest_domain: u32,
        gas_amount: Uint256,
        refund_address: String,
    },
    Claim {},
}

#[cw_serde]
#[derive(QueryResponses)]
#[query_responses(nested)]
pub enum QueryMsg {
    // overrides
    Ownable(OwnableQueryMsg),
    Hook(HookQueryMsg),
    Router(RouterQuery<Addr>),
    Oracle(IgpGasOracleQueryMsg),

    // base
    Igp(IgpQueryMsg),
}

#[cw_serde]
#[derive(QueryResponses)]
pub enum IgpQueryMsg {
    #[returns(DefaultGasResponse)]
    DefaultGas {},

    #[returns(GasForDomainResponse)]
    GasForDomain { domains: Vec<u32> },

    #[returns(GasForDomainResponse)]
    ListGasForDomains {
        offset: Option<u32>,
        limit: Option<u32>,
        order: Option<Order>,
    },

    #[returns(BeneficiaryResponse)]
    Beneficiary {},

    #[returns(QuoteGasPaymentResponse)]
    QuoteGasPayment {
        dest_domain: u32,
        gas_amount: Uint256,
    },
}

impl IgpQueryMsg {
    pub fn wrap(self) -> QueryMsg {
        QueryMsg::Igp(self)
    }
}

#[cw_serde]
pub struct DefaultGasResponse {
    pub gas: u128,
}

#[cw_serde]
pub struct GasForDomainResponse {
    pub gas: Vec<(u32, u128)>,
}

#[cw_serde]
pub struct BeneficiaryResponse {
    pub beneficiary: String,
}

#[cw_serde]
pub struct QuoteGasPaymentResponse {
    pub gas_needed: Uint256,
}

#[cfg(test)]
mod test {
    use cosmwasm_std::HexBinary;

    use super::*;
    use crate::{
        hook::{ExpectedHookQueryMsg, PostDispatchMsg, QuoteDispatchMsg},
        msg_checker,
    };

    #[test]
    fn test_hook_interface() {
        let _checked: ExecuteMsg = msg_checker(
            PostDispatchMsg {
                metadata: HexBinary::default(),
                message: HexBinary::default(),
            }
            .wrap(),
        );

        let _checked: QueryMsg = msg_checker(ExpectedHookQueryMsg::Hook(HookQueryMsg::Mailbox {}));
        let _checked: QueryMsg = msg_checker(
            QuoteDispatchMsg {
                metadata: HexBinary::default(),
                message: HexBinary::default(),
            }
            .request(),
        );
    }
}