Execution trace recording

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Added
+
+- [881](https://github.com/FuelLabs/fuel-vm/pull/881): Support for capturing execution traces.
+
 ### Fixed
 - [879](https://github.com/FuelLabs/fuel-vm/pull/879): Debugger state wasn't propagated in contract contexts.
 - [878](https://github.com/FuelLabs/fuel-vm/pull/878): Fix the transaction de/serialization that wasn't backward compatible with the addition of the new policy.

fuel-vm/Cargo.toml

@@ -44,6 +44,7 @@ percent-encoding = { version = "2.3", features = [
 primitive-types = { version = "0.12", default-features = false }
 rand = { version = "0.8", optional = true }
 serde = { version = "1.0", features = ["derive", "rc"], optional = true }
+serde-big-array = { version = "0.5.1", optional = true }
 serde_with = { version = "3.7", optional = true }
 sha3 = { version = "0.10", default-features = false }
 static_assertions = "1.1"
@@ -95,6 +96,7 @@ da-compression = ["fuel-compression", "fuel-tx/da-compression"]
 serde = [
     "dep:serde",
     "dep:serde_with",
+    "dep:serde-big-array",
     "hashbrown/serde",
     "fuel-asm/serde",
     "fuel-types/serde",

fuel-vm/src/interpreter.rs

@@ -17,6 +17,7 @@ use core::{
     mem,
     ops::Index,
 };
+use trace::ExecutionTracer;
 
 use fuel_asm::{
     Flags,
@@ -67,6 +68,7 @@ mod memory;
 mod metadata;
 mod post_execution;
 mod receipts;
+pub mod trace;
 
 mod debug;
 mod ecal;
@@ -86,6 +88,7 @@ pub use memory::{
     Memory,
     MemoryInstance,
     MemoryRange,
+    MemorySliceChange,
 };
 
 use crate::checked_transaction::{
@@ -132,6 +135,8 @@ pub struct Interpreter<M, S, Tx = (), Ecal = NotSupportedEcal> {
     context: Context,
     balances: RuntimeBalances,
     profiler: Profiler,
+    /// `None` if the excution trace is not enabled.
+    trace: Option<ExecutionTracer<M>>,
     interpreter_params: InterpreterParams,
     /// `PanicContext` after the latest execution. It is consumed by
     /// `append_panic_receipt` and is `PanicContext::None` after consumption.

fuel-vm/src/interpreter/constructors.rs

@@ -81,6 +81,7 @@ where
             context: Context::default(),
             balances: RuntimeBalances::default(),
             profiler: Profiler::default(),
+            trace: None,
             interpreter_params,
             panic_context: PanicContext::None,
             ecal_state,

fuel-vm/src/interpreter/diff/storage.rs

@@ -109,6 +109,7 @@ where
             balances: self.balances,
             panic_context: self.panic_context,
             profiler: self.profiler,
+            trace: self.trace,
             interpreter_params: self.interpreter_params,
             ecal_state: self.ecal_state,
         }
@@ -199,6 +200,7 @@ where
             balances: self.balances,
             panic_context: self.panic_context,
             profiler: self.profiler,
+            trace: self.trace,
             interpreter_params: self.interpreter_params,
             ecal_state: self.ecal_state,
         }

fuel-vm/src/interpreter/executors/instruction.rs

@@ -80,8 +80,15 @@ where
             }
         }
 
-        self.instruction_inner(raw.into())
-            .map_err(|e| InterpreterError::from_runtime(e, raw.into()))
+        let result = self
+            .instruction_inner(raw.into())
+            .map_err(|e| InterpreterError::from_runtime(e, raw.into()));
+
+        if !matches!(result, Err(_) | Ok(ExecuteState::DebugEvent(_))) {
+            self.record_trace_after_instruction();
+        }
+
+        result
     }
 
     fn instruction_inner(

fuel-vm/src/interpreter/memory.rs

@@ -39,7 +39,10 @@ use crate::error::{
     IoResult,
     RuntimeError,
 };
-use alloc::vec::Vec;
+use alloc::{
+    vec,
+    vec::Vec,
+};
 use fuel_storage::{
     Mappable,
     StorageRead,
@@ -54,6 +57,9 @@ mod impl_tests;
 #[cfg(test)]
 mod allocation_tests;
 
+#[cfg(test)]
+mod diff_tests;
+
 #[cfg(test)]
 mod stack_tests;
 
@@ -130,6 +136,15 @@ impl MemoryInstance {
         self.hp = MEM_SIZE;
     }
 
+    /// Make memory equal to another instance, keeping the original allocations.
+    pub fn make_equal(&mut self, other: &Self) {
+        self.stack.truncate(0);
+        self.stack.extend_from_slice(&other.stack);
+        self.hp = other.hp;
+        self.heap.truncate(0);
+        self.heap.extend_from_slice(&other.heap);
+    }
+
     /// Offset of the heap section
     fn heap_offset(&self) -> usize {
         MEM_SIZE.saturating_sub(self.heap.len())
@@ -403,6 +418,37 @@ impl MemoryInstance {
         &self.heap
     }
 
+    /// Diff of from `self` to `new` memory state.
+    /// Panics if new instance is not possible to reach from the current one,
+    /// for instance if it has smaller stack or heap allocation.
+    pub fn diff_patches(&self, new: &MemoryInstance) -> Vec<MemorySliceChange> {
+        let mut changes = Vec::new();
+        let mut current_change: Option<MemorySliceChange> = None;
+
+        for i in 0..MEM_SIZE {
+            let [old_value] = self.read_bytes(i).unwrap_or([0]);
+            let [new_value] = new.read_bytes(i).unwrap_or([0]);
+
+            if old_value != new_value {
+                if let Some(change) = current_change.as_mut() {
+                    change.data.push(new_value);
+                } else {
+                    current_change = Some(MemorySliceChange {
+                        global_start: i,
+                        data: vec![new_value],
+                    });
+                }
+            } else if let Some(change) = current_change.take() {
+                changes.push(change);
+            }
+        }
+        if let Some(change) = current_change.take() {
+            changes.push(change);
+        }
+
+        changes
+    }
+
     /// Returns a `MemoryRollbackData` that can be used to achieve the state of the
     /// `desired_memory_state` instance.
     pub fn collect_rollback_data(
@@ -499,14 +545,19 @@ fn get_changes(
     changes
 }
 
-#[derive(Debug, Clone)]
-struct MemorySliceChange {
-    global_start: usize,
-    data: Vec<u8>,
+/// Memory change at a specific location.
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct MemorySliceChange {
+    /// Start address of the change. Global address.
+    pub global_start: usize,
+    /// Data that was changed.
+    pub data: Vec<u8>,
 }
 
 /// The container for the data used to rollback memory changes.
 #[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct MemoryRollbackData {
     /// Desired stack pointer.
     sp: usize,