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
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
//! State machine of the interpreter.
use crate::backtrace::Backtrace;
use crate::error::InterpreterError;
use crate::interpreter::Interpreter;
use crate::state::StateTransitionRef;
use crate::storage::InterpreterStorage;
use fuel_tx::{Receipt, Transaction};
use std::{mem, slice};
#[derive(Debug)]
/// State machine to execute transactions and provide runtime entities on
/// demand.
///
/// Builder pattern for [`Interpreter`]. Follows the recommended `Non-consuming
/// builder`.
///
/// Based on <https://doc.rust-lang.org/1.5.0/style/ownership/builders.html#non-consuming-builders-preferred>
pub struct Transactor<'a, S> {
interpreter: Interpreter<S>,
state_transition: Option<StateTransitionRef<'a>>,
error: Option<InterpreterError>,
}
impl<'a, S> Transactor<'a, S> {
/// Transactor constructor
pub fn new(storage: S) -> Self {
Interpreter::with_storage(storage).into()
}
/// State transition representation after the execution of a transaction.
///
/// Will be `None` if the last transaction resulted in a VM panic, or if no
/// transaction was executed.
pub const fn state_transition(&self) -> Option<&StateTransitionRef<'a>> {
self.state_transition.as_ref()
}
/// Receipts after the execution of a transaction.
///
/// Follows the same criteria as [`Self::state_transition`] to return
/// `None`.
pub fn receipts(&self) -> Option<&[Receipt]> {
// TODO improve implementation without changing signature
self.state_transition().map(|s| {
let receipts = s.receipts();
let ptr = receipts.as_ptr();
let len = receipts.len();
// Safety: StateTransitionRef is bound to 'a
//
// We can enforce this as a compiler rule by requiring `receipts(&'a self)`, but
// then the consumers of this API will face unnecessary lifetime complexity
unsafe { slice::from_raw_parts(ptr, len) }
})
}
/// Interpreter error representation after the execution of a transaction.
///
/// Follows the same criteria as [`Self::state_transition`] to return
/// `None`.
///
/// Will be `None` if the last transaction resulted successful, or if no
/// transaction was executed.
pub const fn error(&self) -> Option<&InterpreterError> {
self.error.as_ref()
}
/// Generate a backtrace when at least one receipt of `ScriptResult` was
/// found.
pub fn backtrace(&self) -> Option<Backtrace> {
self.receipts()
.map(|r| r.iter().find_map(Receipt::result))
.flatten()
.copied()
.map(|result| Backtrace::from_vm_error(&self.interpreter, result))
}
/// Returns true if last transaction execution was successful
pub const fn is_success(&self) -> bool {
self.state_transition.is_some()
}
/// Returns true if last transaction execution was erroneous
pub const fn is_error(&self) -> bool {
self.error.is_some()
}
/// Result representation of the last executed transaction.
///
/// Will return `None` if no transaction was executed.
pub fn result(&self) -> Result<&StateTransitionRef<'a>, &InterpreterError> {
let state = self.state_transition.as_ref();
let error = self.error.as_ref();
match (state, error) {
(Some(s), None) => Ok(s),
(None, Some(e)) => Err(e),
// Cover also inconsistent states such as `(Some, Some)`
_ => Err(&InterpreterError::NoTransactionInitialized),
}
}
/// Convert this transaction into the underlying VM instance.
///
/// This isn't a two-way operation since if you convert this instance into
/// the raw VM, then you lose the transactor state.
pub fn interpreter(self) -> Interpreter<S> {
self.into()
}
}
impl<S> Transactor<'_, S>
where
S: InterpreterStorage,
{
/// Execute a transaction, and return the new state of the transactor
pub fn transact(&mut self, tx: Transaction) -> &mut Self {
match self.interpreter.transact(tx) {
Ok(s) => {
// Safety: cast `StateTransitionRef<'_>` to `StateTransitionRef<'a>` since it
// was generated with the same lifetime of `self.interpreter`
//
// `self.interpreter` is bound to `'a` since its bound to `self`
let s = unsafe { mem::transmute(s) };
self.state_transition.replace(s);
self.error.take();
}
Err(e) => {
self.state_transition.take();
self.error.replace(e);
}
}
self
}
}
impl<S> From<Interpreter<S>> for Transactor<'_, S> {
fn from(interpreter: Interpreter<S>) -> Self {
let state_transition = None;
let error = None;
Self {
interpreter,
state_transition,
error,
}
}
}
impl<S> From<Transactor<'_, S>> for Interpreter<S> {
fn from(transactor: Transactor<S>) -> Self {
transactor.interpreter
}
}
impl<S> AsRef<Interpreter<S>> for Transactor<'_, S> {
fn as_ref(&self) -> &Interpreter<S> {
&self.interpreter
}
}
impl<S> AsRef<S> for Transactor<'_, S> {
fn as_ref(&self) -> &S {
self.interpreter.as_ref()
}
}
impl<S> AsMut<S> for Transactor<'_, S> {
fn as_mut(&mut self) -> &mut S {
self.interpreter.as_mut()
}
}
impl<S> Default for Transactor<'_, S>
where
S: Default,
{
fn default() -> Self {
Self::new(Default::default())
}
}