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

//! In-memory client implementation

use crate::{
    backtrace::Backtrace,
    checked_transaction::Checked,
    gas::GasCosts,
    state::StateTransitionRef,
    storage::MemoryStorage,
    transactor::Transactor,
};

use fuel_tx::{
    ConsensusParameters,
    Create,
    Receipt,
    Script,
};

#[derive(Default, Debug)]
/// Client implementation with in-memory storage backend.
pub struct MemoryClient {
    transactor: Transactor<MemoryStorage, Script>,
}

impl AsRef<MemoryStorage> for MemoryClient {
    fn as_ref(&self) -> &MemoryStorage {
        self.transactor.as_ref()
    }
}

impl AsMut<MemoryStorage> for MemoryClient {
    fn as_mut(&mut self) -> &mut MemoryStorage {
        self.transactor.as_mut()
    }
}

impl MemoryClient {
    /// Create a new instance of the memory client out of a provided storage.
    pub fn new(
        storage: MemoryStorage,
        params: ConsensusParameters,
        gas_costs: GasCosts,
    ) -> Self {
        Self {
            transactor: Transactor::new(storage, params, gas_costs),
        }
    }

    /// Create a new instance of the memory client out of a provided storage.
    pub fn from_txtor(transactor: Transactor<MemoryStorage, Script>) -> Self {
        Self { transactor }
    }

    /// If a transaction was executed and produced a VM panic, returns the
    /// backtrace; return `None` otherwise.
    pub fn backtrace(&self) -> Option<Backtrace> {
        self.transactor.backtrace()
    }

    /// If a transaction was successfully executed, returns the produced
    /// receipts; return `None` otherwise.
    pub fn receipts(&self) -> Option<&[Receipt]> {
        self.transactor.receipts()
    }

    /// State transition representation after the execution of a transaction.
    pub fn state_transition(&self) -> Option<StateTransitionRef<'_, Script>> {
        self.transactor.state_transition()
    }

    /// Deploys a `Create` transaction.
    pub fn deploy(&mut self, tx: Checked<Create>) -> Option<Create> {
        self.transactor.deploy(tx).ok()
    }

    /// Execute a transaction.
    ///
    /// Since the memory storage is `Infallible`, associatively, the memory
    /// client should also be.
    pub fn transact(&mut self, tx: Checked<Script>) -> &[Receipt] {
        self.transactor.transact(tx);

        // TODO `Transactor::result` should accept error as generic so compile-time
        // constraints can be applied.
        //
        // In this case, we should expect `Infallible` error.
        if let Ok(state) = self.transactor.result() {
            if state.should_revert() {
                self.transactor.as_mut().revert();
            } else {
                self.transactor.as_mut().commit();
            }
        } else {
            // if vm failed to execute, revert storage just in case
            self.transactor.as_mut().revert();
        }

        self.transactor.receipts().unwrap_or_default()
    }

    /// Persist the changes caused by [`Self::transact`].
    pub fn persist(&mut self) {
        self.as_mut().persist();
    }

    /// Consensus parameters
    pub const fn params(&self) -> &ConsensusParameters {
        self.transactor.params()
    }

    /// Tx memory offset
    pub const fn tx_offset(&self) -> usize {
        self.transactor.tx_offset()
    }

    /// Gas costs for opcodes
    pub fn gas_costs(&self) -> &GasCosts {
        self.transactor.gas_costs()
    }
}

impl From<MemoryStorage> for MemoryClient {
    fn from(s: MemoryStorage) -> Self {
        Self::new(s, Default::default(), Default::default())
    }
}

impl From<MemoryClient> for Transactor<MemoryStorage, Script> {
    fn from(client: MemoryClient) -> Self {
        client.transactor
    }
}