polytone-voice 1.0.0

The Polytone Voice contract, recieving notes over IBC and vocalizing them on the host chain via account proxy 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

use cosmwasm_std::{Addr, Empty, Uint64};
use cw_multi_test::{App, AppResponse, Contract, ContractWrapper, Executor};

use crate::msg::QueryMsg::{BlockMaxGas, ProxyCodeId};
use crate::msg::{InstantiateMsg, MigrateMsg};

pub const CREATOR_ADDR: &str = "creator";

fn voice_contract() -> Box<dyn Contract<Empty>> {
    let contract = ContractWrapper::new(
        crate::contract::execute,
        crate::contract::instantiate,
        crate::contract::query,
    )
    .with_migrate(crate::contract::migrate);
    Box::new(contract)
}

pub(crate) struct Suite {
    app: App,
    pub _admin: Addr,
    pub voice_address: Addr,
    pub voice_code: u64,
}

pub(crate) struct SuiteBuilder {
    pub instantiate: InstantiateMsg,
}

impl Default for SuiteBuilder {
    fn default() -> Self {
        Self {
            instantiate: InstantiateMsg {
                proxy_code_id: Uint64::new(9999),
                block_max_gas: Uint64::new(110_000),
            },
        }
    }
}

impl SuiteBuilder {
    pub fn build(self) -> Suite {
        let mut app = App::default();

        let voice_code = app.store_code(voice_contract());

        let voice_address = app
            .instantiate_contract(
                voice_code,
                Addr::unchecked(CREATOR_ADDR),
                &self.instantiate,
                &[],
                "voice contract",
                Some(CREATOR_ADDR.to_string()),
            )
            .unwrap();

        Suite {
            app,
            _admin: Addr::unchecked(CREATOR_ADDR),
            voice_address,
            voice_code,
        }
    }

    pub fn with_block_max_gas(mut self, limit: Uint64) -> Self {
        self.instantiate.block_max_gas = limit;
        self
    }

    pub fn with_proxy_code_id(mut self, code_id: Uint64) -> Self {
        self.instantiate.proxy_code_id = code_id;
        self
    }
}

impl Suite {
    pub fn store_voice_contract(&mut self) -> u64 {
        self.app.store_code(voice_contract())
    }
}

// query
impl Suite {
    pub fn query_block_max_gas(&self) -> u64 {
        self.app
            .wrap()
            .query_wasm_smart(&self.voice_address, &BlockMaxGas)
            .unwrap()
    }

    pub fn query_proxy_code_id(&self) -> u64 {
        self.app
            .wrap()
            .query_wasm_smart(&self.voice_address, &ProxyCodeId)
            .unwrap()
    }
}

// migrate
impl Suite {
    pub fn update(
        &mut self,
        sender: Addr,
        contract_code_id: u64,
        block_max_gas: u64,
    ) -> anyhow::Result<AppResponse> {
        self.app.migrate_contract(
            sender,
            self.voice_address.clone(),
            &MigrateMsg::WithUpdate {
                proxy_code_id: contract_code_id.into(),
                block_max_gas: block_max_gas.into(),
            },
            self.voice_code,
        )
    }
}

// assertion helpers
impl Suite {
    pub fn assert_block_max_gas(&self, val: u64) {
        let curr = self.query_block_max_gas();
        assert_eq!(curr, val);
    }

    pub fn assert_proxy_code(&self, val: u64) {
        let curr = self.query_proxy_code_id();
        assert_eq!(curr, val);
    }
}