ink_engine/
test_api.rs

1// Copyright (C) Use Ink (UK) Ltd.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use crate::{
16    ext::Engine,
17    types::{
18        Balance,
19        BlockNumber,
20        BlockTimestamp,
21        H160,
22    },
23    AccountError,
24    Error,
25};
26use ink_primitives::{
27    AccountId,
28    U256,
29};
30use std::collections::HashMap;
31
32/// Record for an emitted event.
33#[derive(Debug, Clone)]
34pub struct EmittedEvent {
35    /// Recorded topics of the emitted event.
36    pub topics: Vec<Vec<u8>>,
37    /// Recorded encoding of the emitted event.
38    pub data: Vec<u8>,
39}
40
41/// Recorder for relevant interactions with this crate.
42pub struct DebugInfo {
43    /// Emitted events recorder.
44    emitted_events: Vec<EmittedEvent>,
45    /// The total number of reads to the storage.
46    count_reads: HashMap<H160, usize>,
47    /// The total number of writes to the storage.
48    count_writes: HashMap<H160, usize>,
49    /// The number of storage cells used by each contract.
50    cells_per_contract: HashMap<H160, HashMap<Vec<u8>, bool>>,
51}
52
53impl Default for DebugInfo {
54    fn default() -> Self {
55        Self::new()
56    }
57}
58
59impl DebugInfo {
60    // Creates a new `RecInstance instance.
61    pub fn new() -> Self {
62        Self {
63            emitted_events: Vec::new(),
64            count_reads: HashMap::new(),
65            count_writes: HashMap::new(),
66            cells_per_contract: HashMap::new(),
67        }
68    }
69
70    /// Resets the recorder.
71    pub fn reset(&mut self) {
72        self.count_reads.clear();
73        self.count_writes.clear();
74        self.emitted_events.clear();
75        self.cells_per_contract.clear();
76    }
77
78    /// Increases the number of storage writes for the supplied account by one.
79    #[allow(clippy::arithmetic_side_effects)] // todo
80    pub fn inc_writes(&mut self, addr: H160) {
81        self.count_writes
82            .entry(addr)
83            .and_modify(|v| *v += 1)
84            .or_insert(1);
85    }
86
87    /// Increases the number of storage reads for the supplied account by one.
88    #[allow(clippy::arithmetic_side_effects)] // todo
89    pub fn inc_reads(&mut self, addr: H160) {
90        self.count_reads
91            .entry(addr)
92            .and_modify(|v| *v += 1)
93            .or_insert(1);
94    }
95
96    /// Records that a cell exists for an account under `key`.
97    ///
98    /// Calling this function multiple times won't change the fact that only
99    /// one cell is recorded.
100    pub fn record_cell_for_account(&mut self, addr: H160, key: Vec<u8>) {
101        self.cells_per_contract
102            .entry(addr)
103            .and_modify(|hm| {
104                let _ = hm.insert(key.clone(), true);
105            })
106            .or_insert({
107                let mut hm = HashMap::new();
108                hm.insert(key, true);
109                hm
110            });
111    }
112
113    /// Removes the cell under `key` for the supplied account.
114    ///
115    /// Returns the removed cell, if there was one.
116    pub fn remove_cell_for_account(&mut self, addr: H160, key: Vec<u8>) -> Option<bool> {
117        self.cells_per_contract
118            .get_mut(&addr)
119            .map(|hm| hm.remove(&key))
120            .unwrap_or(None)
121    }
122
123    /// Records an event.
124    pub fn record_event(&mut self, event: EmittedEvent) {
125        self.emitted_events.push(event);
126    }
127}
128
129impl Engine {
130    /// Resets the environment.
131    pub fn initialize_or_reset(&mut self) {
132        self.exec_context.reset();
133        self.database.clear();
134        self.debug_info.reset();
135    }
136
137    /// Returns the total number of reads and writes of the contract's storage.
138    pub fn get_contract_storage_rw(&self, addr: H160) -> (usize, usize) {
139        let reads = self.debug_info.count_reads.get(&addr).unwrap_or(&0);
140        let writes = self.debug_info.count_writes.get(&addr).unwrap_or(&0);
141        (*reads, *writes)
142    }
143
144    /// Returns the total number of reads executed.
145    pub fn count_reads(&self) -> usize {
146        self.debug_info.count_reads.values().sum()
147    }
148
149    /// Returns the total number of writes executed.
150    pub fn count_writes(&self) -> usize {
151        self.debug_info.count_writes.values().sum()
152    }
153
154    /// Sets a caller for the next call.
155    pub fn set_caller(&mut self, caller: H160) {
156        self.exec_context.caller = caller;
157    }
158
159    /// Sets a known contract by adding it to a vector of known contracts accounts
160    pub fn set_contract(&mut self, caller: H160) {
161        self.exec_context.contracts.push(caller);
162    }
163
164    /// Sets the callee for the next call.
165    pub fn set_callee(&mut self, callee: H160) {
166        self.exec_context.callee = Some(callee);
167    }
168
169    /// Returns the amount of storage cells used by the contract `addr`.
170    ///
171    /// Returns `None` if the contract `addr` is non-existent.
172    pub fn count_used_storage_cells(&self, addr: &H160) -> Result<usize, Error> {
173        let cells = self
174            .debug_info
175            .cells_per_contract
176            .get(addr)
177            .ok_or(Error::Account(AccountError::NoContractForId(*addr)))?;
178        Ok(cells.len())
179    }
180
181    /// Advances the chain by a single block.
182    pub fn advance_block(&mut self) {
183        self.exec_context.block_number = self
184            .exec_context
185            .block_number
186            .checked_add(1)
187            .expect("failed to add");
188        self.exec_context.block_timestamp = self
189            .exec_context
190            .block_timestamp
191            .checked_add(self.chain_spec.block_time)
192            .expect("failed to add");
193    }
194
195    /// Returns the callee, i.e. the currently executing contract.
196    pub fn get_callee(&self) -> H160 {
197        self.exec_context.callee()
198    }
199
200    /// Returns boolean value indicating whether the account is a contract
201    pub fn is_contract(&self, addr: &H160) -> bool {
202        self.exec_context.contracts.contains(addr)
203    }
204
205    /// Returns the recorded emitted events in order.
206    pub fn get_emitted_events(&self) -> impl Iterator<Item = EmittedEvent> {
207        self.debug_info.emitted_events.clone().into_iter()
208    }
209
210    /// Returns the current balance of `addr`.
211    pub fn get_acc_balance(&self, addr: AccountId) -> Result<Balance, Error> {
212        self.database
213            .get_acc_balance(&addr)
214            .ok_or(Error::Account(AccountError::NoAccountForId(addr)))
215    }
216
217    /// Sets the balance of `addr` to `new_balance`.
218    pub fn set_acc_balance(&mut self, addr: AccountId, new_balance: Balance) {
219        self.database.set_acc_balance(&addr, new_balance);
220    }
221
222    /// Returns the current balance of `addr`.
223    pub fn get_balance(&self, addr: H160) -> Result<U256, Error> {
224        self.database
225            .get_balance(&addr)
226            .ok_or(Error::Account(AccountError::NoContractForId(addr)))
227    }
228
229    /// Sets the balance of `addr` to `new_balance`.
230    pub fn set_balance(&mut self, addr: H160, new_balance: U256) {
231        self.database.set_balance(&addr, new_balance);
232    }
233
234    /// Sets the value transferred from the caller to the callee as part of the call.
235    pub fn set_value_transferred(&mut self, value: U256) {
236        self.exec_context.value_transferred = value;
237    }
238
239    /// Set the block timestamp for the execution context.
240    pub fn set_block_timestamp(&mut self, new_block_timestamp: BlockTimestamp) {
241        self.exec_context.block_timestamp = new_block_timestamp;
242    }
243
244    /// Set the block number for the execution context.
245    pub fn set_block_number(&mut self, new_block_number: BlockNumber) {
246        self.exec_context.block_number = new_block_number;
247    }
248}
249
250#[cfg(test)]
251mod tests {
252    use super::*;
253
254    #[test]
255    fn setting_getting_callee() {
256        let mut engine = Engine::new();
257        let addr = H160::from([1; 20]);
258        engine.set_callee(addr);
259        assert_eq!(engine.get_callee(), addr);
260    }
261
262    #[test]
263    fn count_cells_per_account_must_stay_the_same() {
264        // given
265        let mut engine = Engine::new();
266        let addr = H160::from([1; 20]);
267        engine.set_callee(addr);
268        let key: &[u8; 32] = &[0x42; 32];
269        engine.set_storage(key, &[0x05_u8; 5]);
270        assert_eq!(engine.count_used_storage_cells(&addr), Ok(1));
271
272        // when
273        // we set the storage a second time
274        engine.set_storage(key, &[0x05_u8; 6]);
275
276        // then
277        // the amount of storage cells used must have stayed the same
278        assert_eq!(engine.count_used_storage_cells(&addr), Ok(1));
279    }
280
281    #[test]
282    fn count_cells_per_account_must_be_reset() {
283        // given
284        let mut engine = Engine::new();
285        let addr = H160::from([1; 20]);
286        engine.set_callee(addr);
287        let key: &[u8; 32] = &[0x42; 32];
288        engine.set_storage(key, &[0x05_u8; 5]);
289        assert_eq!(engine.count_used_storage_cells(&addr), Ok(1));
290
291        // when
292        engine.clear_storage(key);
293
294        // then
295        assert_eq!(engine.count_used_storage_cells(&addr), Ok(0));
296    }
297
298    #[test]
299    fn count_total_writes() {
300        // given
301        let mut engine = Engine::new();
302        let key: &[u8; 32] = &[0x42; 32];
303
304        // when
305        engine.set_callee(H160::from([1; 20]));
306        engine.set_storage(key, &[0x05_u8; 5]);
307        engine.set_storage(key, &[0x05_u8; 6]);
308        engine.get_storage(key).unwrap();
309
310        engine.set_callee(H160::from([2; 20]));
311        engine.set_storage(key, &[0x07_u8; 7]);
312        engine.get_storage(key).unwrap();
313
314        // then
315        assert_eq!(engine.count_writes(), 3);
316        assert_eq!(engine.count_reads(), 2);
317    }
318}
ink_engine/test_api.rs

ink_engine/
test_api.rs
