Allow external construction of the storage slot hashes (#99)

# Summary

Adds support for external construction of the storage slot hashes

# Details 
- Adds a new method to `StorageSlotHashes` so it can be constructed with a predefined BitMap of the hashes. 
- Adds a new method to `LiftingPasses` so it can be constructed with a vector of passes 

# Checklist

- [x] Code is formatted by Rustfmt.
- [x] Documentation has been updated if necessary.

Fixes #97

src/inference/lift/mod.rs

@@ -66,6 +66,14 @@ pub struct LiftingPasses {
 }
 
 impl LiftingPasses {
+    /// Creates a new instance of the lifting pass with the provided `passes`
+    #[must_use]
+    pub fn new(passes: impl Into<Vec<Box<dyn Lift>>>) -> Self {
+        Self {
+            passes: passes.into(),
+        }
+    }
+
     /// Adds the `pass` to the end of the pass ordering.
     ///
     /// If a pass of the given type already exists in the ordering, it will not

src/inference/lift/recognise_hashed_slots.rs

@@ -2,6 +2,8 @@
 //! [`SLOT_COUNT`] storage slot indices in order to make the recognition of
 //! dynamic array accesses easier.
 
+use std::sync::{Arc, RwLock};
+
 use bimap::BiMap;
 use ethnum::U256;
 use sha3::{Digest, Keccak256};
@@ -28,17 +30,25 @@ pub const SLOT_COUNT: usize = 10000;
 ///
 /// where:
 /// - `C` is the sha3 hash of one of the first [`SLOT_COUNT`] integers.
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug)]
 pub struct StorageSlotHashes {
-    hashes: BiMap<U256, usize>,
+    hashes: Arc<RwLock<BiMap<U256, usize>>>,
 }
 
 impl StorageSlotHashes {
     /// Creates a new instance of the mapping access lifting pass.
     #[must_use]
     pub fn new() -> Box<Self> {
-        let hashes = Self::make_hashes(SLOT_COUNT);
-        Box::new(Self { hashes })
+        let hashes = Arc::new(RwLock::new(Self::make_hashes(SLOT_COUNT)));
+        Self::new_with_hashes(hashes)
+    }
+
+    // Creates a new instance with the provided hashes
+    #[must_use]
+    pub fn new_with_hashes(hashes: impl Into<Arc<RwLock<BiMap<U256, usize>>>>) -> Box<Self> {
+        Box::new(Self {
+            hashes: hashes.into(),
+        })
     }
 
     /// Generates the slot hashes for the first `count` slots, assuming
@@ -79,17 +89,22 @@ impl Lift for StorageSlotHashes {
 
             // Now we can look up the hash we found, and convert it to the `Sha3` of a known
             // value if it is one.
-            if let Some(slot_index) = hashes.get_by_left(&known_value.value_le()) {
-                let data = RSV::new_known_value(
-                    value_clone.instruction_pointer(),
-                    KnownWord::from(*slot_index),
-                    value_clone.provenance(),
-                    None,
-                );
-
-                Some(RSVD::Sha3 { data })
-            } else {
-                None
+            match hashes.read() {
+                Ok(hashes) => {
+                    if let Some(slot_index) = hashes.get_by_left(&known_value.value_le()) {
+                        let data = RSV::new_known_value(
+                            value_clone.instruction_pointer(),
+                            KnownWord::from(*slot_index),
+                            value_clone.provenance(),
+                            None,
+                        );
+
+                        Some(RSVD::Sha3 { data })
+                    } else {
+                        None
+                    }
+                }
+                _ => None,
             }
         };