drink 0.18.0

Minimal sufficient architecture that allows for a fully functional ink! contract development
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

use parity_scale_codec::Encode;
use sp_runtime_interface::runtime_interface;

use crate::sp_externalities::{decl_extension, ExternalitiesExt};

/// Contracts pallet outsources debug callbacks through this runtime interface.
///
/// Essentially, in our case, it just exposes extensions to the runtime.
///
/// At this level, data passed back/forth must be either primitive or implement some specific
/// traits. For simplicity, we just go with primitives and codec encoded data.
#[runtime_interface]
pub trait ContractCallDebugger {
    fn after_call(
        &mut self,
        contract_address: Vec<u8>,
        is_call: bool,
        input_data: Vec<u8>,
        result: Vec<u8>,
    ) {
        if let Some(ext) = self.extension::<TracingExt>() {
            ext.after_call(contract_address, is_call, input_data, result);
        }
    }

    fn intercept_call(
        &mut self,
        contract_address: Vec<u8>,
        is_call: bool,
        input_data: Vec<u8>,
    ) -> Option<Vec<u8>> {
        self.extension::<InterceptingExt>()
            .map(|ext| ext.intercept_call(contract_address, is_call, input_data))
    }
}

/// This trait describes a runtime extension that can be used to debug contract calls.
pub trait TracingExtT {
    /// Called after a contract call is made.
    fn after_call(
        &self,
        _contract_address: Vec<u8>,
        _is_call: bool,
        _input_data: Vec<u8>,
        _result: Vec<u8>,
    ) {
    }
}

decl_extension! {
    /// A wrapper type for the `TracingExtT` debug extension.
    pub struct TracingExt(Box<dyn TracingExtT + Send>);
}

/// This trait describes a runtime extension that can be used to intercept contract calls.
pub trait InterceptingExtT {
    /// Called when a contract call is made.
    ///
    /// The returned value must be a valid codec encoding for `Option<ExecResult>`.
    fn intercept_call(
        &self,
        _contract_address: Vec<u8>,
        _is_call: bool,
        _input_data: Vec<u8>,
    ) -> Vec<u8> {
        // By default, do not intercept, continue with the standard procedure.
        None::<()>.encode()
    }
}

decl_extension! {
    /// A wrapper type for the `InterceptingExtT` debug extension.
    pub struct InterceptingExt(Box<dyn InterceptingExtT + Send>);
}

/// The simplest extension - uses default implementation.
pub struct NoopExt;
impl TracingExtT for NoopExt {}
impl InterceptingExtT for NoopExt {}