feat(evm): make vm.snapshots persistent

evm/src/executor/backend/mod.rs

@@ -880,7 +880,9 @@ impl DatabaseExt for Backend {
         current: &mut Env,
     ) -> Option<JournaledState> {
         trace!(?id, "revert snapshot");
-        if let Some(mut snapshot) = self.inner.snapshots.remove(id) {
+        if let Some(mut snapshot) = self.inner.snapshots.remove_at(id) {
+            // Re-insert snapshot to persist it
+            self.inner.snapshots.insert_at(snapshot.clone(), id);
             // need to check whether there's a global failure which means an error occurred either
             // during the snapshot or even before
             if self.is_global_failure(current_state) {

evm/src/executor/backend/snapshot.rs

@@ -6,7 +6,7 @@ use revm::{
 use serde::{Deserialize, Serialize};
 
 /// A minimal abstraction of a state at a certain point in time
-#[derive(Default, Debug, Serialize, Deserialize)]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
 pub struct StateSnapshot {
     pub accounts: Map<B160, AccountInfo>,
     pub storage: Map<B160, Map<U256, U256>>,

evm/src/executor/fork/database.rs

@@ -114,8 +114,9 @@ impl ForkedDatabase {
     }
 
     pub fn revert_snapshot(&mut self, id: U256) -> bool {
-        let snapshot = { self.snapshots().lock().remove(id) };
+        let snapshot = { self.snapshots().lock().remove_at(id) };
         if let Some(snapshot) = snapshot {
+            self.snapshots().lock().insert_at(snapshot.clone(), id);
             let ForkDbSnapshot {
                 local,
                 snapshot: StateSnapshot { accounts, storage, block_hashes },
@@ -200,7 +201,7 @@ impl DatabaseCommit for ForkedDatabase {
 /// Represents a snapshot of the database
 ///
 /// This mimics `revm::CacheDB`
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct ForkDbSnapshot {
     pub local: CacheDB<SharedBackend>,
     pub snapshot: StateSnapshot,

evm/src/executor/snapshot.rs

@@ -41,12 +41,27 @@ impl<T> Snapshots<T> {
         snapshot
     }
 
+    /// Removes the snapshot with the given `id`.
+    ///
+    /// Does not remove snapshots after it.
+    pub fn remove_at(&mut self, id: U256) -> Option<T> {
+        self.snapshots.remove(&id)
+    }
+
     /// Inserts the new snapshot and returns the id
     pub fn insert(&mut self, snapshot: T) -> U256 {
         let id = self.next_id();
         self.snapshots.insert(id, snapshot);
         id
     }
+
+    /// Inserts the new snapshot at the given `id`.
+    ///
+    ///  Does not auto-increment the next `id`.
+    pub fn insert_at(&mut self, snapshot: T, id: U256) -> U256 {
+        self.snapshots.insert(id, snapshot);
+        id
+    }
 }
 
 impl<T> Default for Snapshots<T> {