diff --git a/Cargo.toml b/Cargo.toml
index 7c27f9ada..c01841bb4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,4 +16,6 @@ stdlib = { package = "acvm_stdlib", version = "0.11.0", path = "stdlib", default
 num-bigint = "0.4"
 num-traits = "0.2"
 
+thiserror = "1.0.21"
+
 serde = { version = "1.0.136", features = ["derive"] }
diff --git a/acir/Cargo.toml b/acir/Cargo.toml
index f2c4dac29..8565ea892 100644
--- a/acir/Cargo.toml
+++ b/acir/Cargo.toml
@@ -12,6 +12,7 @@ rust-version.workspace = true
 [dependencies]
 acir_field.workspace = true
 serde.workspace = true
+thiserror.workspace = true
 
 rmp-serde = "1.1.0"
 flate2 = "1.0.24"
diff --git a/acir/src/native_types/mod.rs b/acir/src/native_types/mod.rs
index 4b54d9388..c54e63095 100644
--- a/acir/src/native_types/mod.rs
+++ b/acir/src/native_types/mod.rs
@@ -1,5 +1,7 @@
 mod expression;
 mod witness;
+mod witness_map;
 
 pub use expression::Expression;
 pub use witness::Witness;
+pub use witness_map::WitnessMap;
diff --git a/acir/src/native_types/witness.rs b/acir/src/native_types/witness.rs
index 5ffd47391..3e9beb510 100644
--- a/acir/src/native_types/witness.rs
+++ b/acir/src/native_types/witness.rs
@@ -1,9 +1,3 @@
-use std::io::Read;
-
-use flate2::{
-    bufread::{DeflateDecoder, DeflateEncoder},
-    Compression,
-};
 use serde::{Deserialize, Serialize};
 
 // Witness might be a misnomer. This is an index that represents the position a witness will take
@@ -27,23 +21,10 @@ impl Witness {
     pub const fn can_defer_constraint(&self) -> bool {
         true
     }
+}
 
-    pub fn to_bytes(
-        witnesses: &std::collections::BTreeMap<Witness, acir_field::FieldElement>,
-    ) -> Vec<u8> {
-        let buf = rmp_serde::to_vec(witnesses).unwrap();
-        let mut deflater = DeflateEncoder::new(buf.as_slice(), Compression::best());
-        let mut buf_c = Vec::new();
-        deflater.read_to_end(&mut buf_c).unwrap();
-        buf_c
-    }
-
-    pub fn from_bytes(
-        bytes: &[u8],
-    ) -> std::collections::BTreeMap<Witness, acir_field::FieldElement> {
-        let mut deflater = DeflateDecoder::new(bytes);
-        let mut buf_d = Vec::new();
-        deflater.read_to_end(&mut buf_d).unwrap();
-        rmp_serde::from_slice(buf_d.as_slice()).unwrap()
+impl From<u32> for Witness {
+    fn from(value: u32) -> Self {
+        Self(value)
     }
 }
diff --git a/acir/src/native_types/witness_map.rs b/acir/src/native_types/witness_map.rs
new file mode 100644
index 000000000..9f814eab3
--- /dev/null
+++ b/acir/src/native_types/witness_map.rs
@@ -0,0 +1,105 @@
+use std::{
+    collections::{btree_map, BTreeMap},
+    io::Read,
+    ops::Index,
+};
+
+use acir_field::FieldElement;
+use flate2::{
+    bufread::{DeflateDecoder, DeflateEncoder},
+    Compression,
+};
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+use crate::native_types::Witness;
+
+#[derive(Debug, Error)]
+pub enum WitnessMapError {
+    #[error(transparent)]
+    MsgpackEncode(#[from] rmp_serde::encode::Error),
+
+    #[error(transparent)]
+    MsgpackDecode(#[from] rmp_serde::decode::Error),
+
+    #[error(transparent)]
+    Deflate(#[from] std::io::Error),
+}
+
+/// A map from the witnesses in a constraint system to the field element values
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default, Serialize, Deserialize)]
+pub struct WitnessMap(BTreeMap<Witness, FieldElement>);
+
+impl WitnessMap {
+    pub fn new() -> Self {
+        Self(BTreeMap::new())
+    }
+    pub fn get(&self, witness: &Witness) -> Option<&FieldElement> {
+        self.0.get(witness)
+    }
+    pub fn get_index(&self, index: u32) -> Option<&FieldElement> {
+        self.0.get(&index.into())
+    }
+    pub fn contains_key(&self, key: &Witness) -> bool {
+        self.0.contains_key(key)
+    }
+    pub fn insert(&mut self, key: Witness, value: FieldElement) -> Option<FieldElement> {
+        self.0.insert(key, value)
+    }
+}
+
+impl Index<&Witness> for WitnessMap {
+    type Output = FieldElement;
+
+    fn index(&self, index: &Witness) -> &Self::Output {
+        &self.0[index]
+    }
+}
+
+pub struct IntoIter(btree_map::IntoIter<Witness, FieldElement>);
+
+impl Iterator for IntoIter {
+    type Item = (Witness, FieldElement);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next()
+    }
+}
+
+impl IntoIterator for WitnessMap {
+    type Item = (Witness, FieldElement);
+    type IntoIter = IntoIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter(self.0.into_iter())
+    }
+}
+
+impl From<BTreeMap<Witness, FieldElement>> for WitnessMap {
+    fn from(value: BTreeMap<Witness, FieldElement>) -> Self {
+        Self(value)
+    }
+}
+
+impl TryFrom<WitnessMap> for Vec<u8> {
+    type Error = WitnessMapError;
+
+    fn try_from(val: WitnessMap) -> Result<Self, Self::Error> {
+        let buf = rmp_serde::to_vec(&val)?;
+        let mut deflater = DeflateEncoder::new(buf.as_slice(), Compression::best());
+        let mut buf_c = Vec::new();
+        deflater.read_to_end(&mut buf_c)?;
+        Ok(buf_c)
+    }
+}
+
+impl TryFrom<&[u8]> for WitnessMap {
+    type Error = WitnessMapError;
+
+    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
+        let mut deflater = DeflateDecoder::new(bytes);
+        let mut buf_d = Vec::new();
+        deflater.read_to_end(&mut buf_d)?;
+        Ok(Self(rmp_serde::from_slice(buf_d.as_slice())?))
+    }
+}
diff --git a/acvm/Cargo.toml b/acvm/Cargo.toml
index e27b14985..2ec9676d0 100644
--- a/acvm/Cargo.toml
+++ b/acvm/Cargo.toml
@@ -12,6 +12,7 @@ rust-version.workspace = true
 [dependencies]
 num-bigint.workspace = true
 num-traits.workspace = true
+thiserror.workspace = true
 
 acir.workspace = true
 stdlib.workspace = true
@@ -28,7 +29,6 @@ k256 = { version = "0.7.2", features = [
     "arithmetic",
 ] }
 indexmap = "1.7.0"
-thiserror = "1.0.21"
 
 [features]
 default = ["bn254"]
diff --git a/acvm/src/lib.rs b/acvm/src/lib.rs
index 24a00dcc9..999646f02 100644
--- a/acvm/src/lib.rs
+++ b/acvm/src/lib.rs
@@ -12,11 +12,10 @@ use acir::{
         opcodes::{BlackBoxFuncCall, FunctionInput},
         Circuit, Opcode,
     },
-    native_types::{Expression, Witness},
+    native_types::{Expression, Witness, WitnessMap},
     BlackBoxFunc,
 };
 use core::fmt::Debug;
-use std::collections::BTreeMap;
 use thiserror::Error;
 
 // re-export acir
@@ -64,44 +63,44 @@ pub trait Backend:
 pub trait PartialWitnessGenerator {
     fn aes(
         &self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         inputs: &[FunctionInput],
         outputs: &[Witness],
     ) -> Result<pwg::OpcodeResolution, OpcodeResolutionError>;
     fn and(
         &self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         lhs: &FunctionInput,
         rhs: &FunctionInput,
         output: &Witness,
     ) -> Result<pwg::OpcodeResolution, OpcodeResolutionError>;
     fn xor(
         &self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         lhs: &FunctionInput,
         rhs: &FunctionInput,
         output: &Witness,
     ) -> Result<pwg::OpcodeResolution, OpcodeResolutionError>;
     fn range(
         &self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         input: &FunctionInput,
     ) -> Result<pwg::OpcodeResolution, OpcodeResolutionError>;
     fn sha256(
         &self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         inputs: &[FunctionInput],
         outputs: &[Witness],
     ) -> Result<pwg::OpcodeResolution, OpcodeResolutionError>;
     fn blake2s(
         &self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         inputs: &[FunctionInput],
         outputs: &[Witness],
     ) -> Result<pwg::OpcodeResolution, OpcodeResolutionError>;
     fn compute_merkle_root(
         &self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         leaf: &FunctionInput,
         index: &FunctionInput,
         hash_path: &[FunctionInput],
@@ -109,7 +108,7 @@ pub trait PartialWitnessGenerator {
     ) -> Result<pwg::OpcodeResolution, OpcodeResolutionError>;
     fn schnorr_verify(
         &self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         public_key_x: &FunctionInput,
         public_key_y: &FunctionInput,
         signature: &[FunctionInput],
@@ -118,19 +117,19 @@ pub trait PartialWitnessGenerator {
     ) -> Result<pwg::OpcodeResolution, OpcodeResolutionError>;
     fn pedersen(
         &self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         inputs: &[FunctionInput],
         outputs: &[Witness],
     ) -> Result<pwg::OpcodeResolution, OpcodeResolutionError>;
     fn hash_to_field_128_security(
         &self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         inputs: &[FunctionInput],
         outputs: &Witness,
     ) -> Result<pwg::OpcodeResolution, OpcodeResolutionError>;
     fn ecdsa_secp256k1(
         &self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         public_key_x: &[FunctionInput],
         public_key_y: &[FunctionInput],
         signature: &[FunctionInput],
@@ -139,13 +138,13 @@ pub trait PartialWitnessGenerator {
     ) -> Result<pwg::OpcodeResolution, OpcodeResolutionError>;
     fn fixed_base_scalar_mul(
         &self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         input: &FunctionInput,
         outputs: &[Witness],
     ) -> Result<pwg::OpcodeResolution, OpcodeResolutionError>;
     fn keccak256(
         &self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         inputs: &[FunctionInput],
         outputs: &[Witness],
     ) -> Result<pwg::OpcodeResolution, OpcodeResolutionError>;
@@ -187,7 +186,7 @@ pub trait ProofSystemCompiler {
     fn prove_with_pk(
         &self,
         circuit: &Circuit,
-        witness_values: BTreeMap<Witness, FieldElement>,
+        witness_values: WitnessMap,
         proving_key: &[u8],
     ) -> Result<Vec<u8>, Self::Error>;
 
@@ -195,7 +194,7 @@ pub trait ProofSystemCompiler {
     fn verify_with_vk(
         &self,
         proof: &[u8],
-        public_inputs: BTreeMap<Witness, FieldElement>,
+        public_inputs: WitnessMap,
         circuit: &Circuit,
         verification_key: &[u8],
     ) -> Result<bool, Self::Error>;
@@ -272,7 +271,7 @@ mod test {
             opcodes::{FunctionInput, OracleData},
             Opcode,
         },
-        native_types::{Expression, Witness},
+        native_types::{Expression, Witness, WitnessMap},
         FieldElement,
     };
 
@@ -286,7 +285,7 @@ mod test {
     impl PartialWitnessGenerator for StubbedPwg {
         fn aes(
             &self,
-            _initial_witness: &mut BTreeMap<Witness, FieldElement>,
+            _initial_witness: &mut WitnessMap,
             _inputs: &[FunctionInput],
             _outputs: &[Witness],
         ) -> Result<OpcodeResolution, OpcodeResolutionError> {
@@ -294,7 +293,7 @@ mod test {
         }
         fn and(
             &self,
-            _initial_witness: &mut BTreeMap<Witness, FieldElement>,
+            _initial_witness: &mut WitnessMap,
             _lhs: &FunctionInput,
             _rhs: &FunctionInput,
             _output: &Witness,
@@ -303,7 +302,7 @@ mod test {
         }
         fn xor(
             &self,
-            _initial_witness: &mut BTreeMap<Witness, FieldElement>,
+            _initial_witness: &mut WitnessMap,
             _lhs: &FunctionInput,
             _rhs: &FunctionInput,
             _output: &Witness,
@@ -312,14 +311,14 @@ mod test {
         }
         fn range(
             &self,
-            _initial_witness: &mut BTreeMap<Witness, FieldElement>,
+            _initial_witness: &mut WitnessMap,
             _input: &FunctionInput,
         ) -> Result<OpcodeResolution, OpcodeResolutionError> {
             panic!("Path not trodden by this test")
         }
         fn sha256(
             &self,
-            _initial_witness: &mut BTreeMap<Witness, FieldElement>,
+            _initial_witness: &mut WitnessMap,
             _inputs: &[FunctionInput],
             _outputs: &[Witness],
         ) -> Result<OpcodeResolution, OpcodeResolutionError> {
@@ -327,7 +326,7 @@ mod test {
         }
         fn blake2s(
             &self,
-            _initial_witness: &mut BTreeMap<Witness, FieldElement>,
+            _initial_witness: &mut WitnessMap,
             _inputs: &[FunctionInput],
             _outputs: &[Witness],
         ) -> Result<OpcodeResolution, OpcodeResolutionError> {
@@ -335,7 +334,7 @@ mod test {
         }
         fn compute_merkle_root(
             &self,
-            _initial_witness: &mut BTreeMap<Witness, FieldElement>,
+            _initial_witness: &mut WitnessMap,
             _leaf: &FunctionInput,
             _index: &FunctionInput,
             _hash_path: &[FunctionInput],
@@ -345,7 +344,7 @@ mod test {
         }
         fn schnorr_verify(
             &self,
-            _initial_witness: &mut BTreeMap<Witness, FieldElement>,
+            _initial_witness: &mut WitnessMap,
             _public_key_x: &FunctionInput,
             _public_key_y: &FunctionInput,
             _signature: &[FunctionInput],
@@ -356,7 +355,7 @@ mod test {
         }
         fn pedersen(
             &self,
-            _initial_witness: &mut BTreeMap<Witness, FieldElement>,
+            _initial_witness: &mut WitnessMap,
             _inputs: &[FunctionInput],
             _outputs: &[Witness],
         ) -> Result<OpcodeResolution, OpcodeResolutionError> {
@@ -364,7 +363,7 @@ mod test {
         }
         fn hash_to_field_128_security(
             &self,
-            _initial_witness: &mut BTreeMap<Witness, FieldElement>,
+            _initial_witness: &mut WitnessMap,
             _inputs: &[FunctionInput],
             _output: &Witness,
         ) -> Result<OpcodeResolution, OpcodeResolutionError> {
@@ -372,7 +371,7 @@ mod test {
         }
         fn ecdsa_secp256k1(
             &self,
-            _initial_witness: &mut BTreeMap<Witness, FieldElement>,
+            _initial_witness: &mut WitnessMap,
             _public_key_x: &[FunctionInput],
             _public_key_y: &[FunctionInput],
             _signature: &[FunctionInput],
@@ -383,7 +382,7 @@ mod test {
         }
         fn fixed_base_scalar_mul(
             &self,
-            _initial_witness: &mut BTreeMap<Witness, FieldElement>,
+            _initial_witness: &mut WitnessMap,
             _input: &FunctionInput,
             _outputs: &[Witness],
         ) -> Result<OpcodeResolution, OpcodeResolutionError> {
@@ -391,7 +390,7 @@ mod test {
         }
         fn keccak256(
             &self,
-            _initial_witness: &mut BTreeMap<Witness, FieldElement>,
+            _initial_witness: &mut WitnessMap,
             _inputs: &[FunctionInput],
             _outputs: &[Witness],
         ) -> Result<OpcodeResolution, OpcodeResolutionError> {
@@ -448,7 +447,8 @@ mod test {
         let mut witness_assignments = BTreeMap::from([
             (Witness(1), FieldElement::from(2u128)),
             (Witness(2), FieldElement::from(3u128)),
-        ]);
+        ])
+        .into();
         let mut blocks = Blocks::default();
         let solver_status = pwg::solve(&backend, &mut witness_assignments, &mut blocks, opcodes)
             .expect("should stall on oracle");
diff --git a/acvm/src/pwg.rs b/acvm/src/pwg.rs
index c26b6469a..be31c057a 100644
--- a/acvm/src/pwg.rs
+++ b/acvm/src/pwg.rs
@@ -3,10 +3,9 @@
 use crate::{OpcodeNotSolvable, OpcodeResolutionError, PartialWitnessGenerator};
 use acir::{
     circuit::opcodes::{Opcode, OracleData},
-    native_types::{Expression, Witness},
+    native_types::{Expression, Witness, WitnessMap},
     FieldElement,
 };
-use std::collections::BTreeMap;
 
 use self::{
     arithmetic::ArithmeticSolver, block::Blocks, directives::solve_directives, oracle::OracleSolver,
@@ -50,7 +49,7 @@ pub enum OpcodeResolution {
 
 pub fn solve(
     backend: &impl PartialWitnessGenerator,
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
     blocks: &mut Blocks,
     mut opcode_to_solve: Vec<Opcode>,
 ) -> Result<PartialWitnessGeneratorStatus, OpcodeResolutionError> {
@@ -133,7 +132,7 @@ pub fn solve(
 // If the witness has no assignment, then
 // an error is returned
 pub fn witness_to_value(
-    initial_witness: &BTreeMap<Witness, FieldElement>,
+    initial_witness: &WitnessMap,
     witness: Witness,
 ) -> Result<&FieldElement, OpcodeResolutionError> {
     match initial_witness.get(&witness) {
@@ -146,7 +145,7 @@ pub fn witness_to_value(
 // TODO versus just getting values from Witness
 pub fn get_value(
     expr: &Expression,
-    initial_witness: &BTreeMap<Witness, FieldElement>,
+    initial_witness: &WitnessMap,
 ) -> Result<FieldElement, OpcodeResolutionError> {
     let expr = ArithmeticSolver::evaluate(expr, initial_witness);
     match expr.to_const() {
@@ -166,7 +165,7 @@ pub fn get_value(
 fn insert_value(
     witness: &Witness,
     value_to_insert: FieldElement,
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
 ) -> Result<(), OpcodeResolutionError> {
     let optional_old_value = initial_witness.insert(*witness, value_to_insert);
 
diff --git a/acvm/src/pwg/arithmetic.rs b/acvm/src/pwg/arithmetic.rs
index c76e4210f..f943ee00b 100644
--- a/acvm/src/pwg/arithmetic.rs
+++ b/acvm/src/pwg/arithmetic.rs
@@ -1,8 +1,7 @@
 use acir::{
-    native_types::{Expression, Witness},
+    native_types::{Expression, Witness, WitnessMap},
     FieldElement,
 };
-use std::collections::BTreeMap;
 
 use crate::{pwg::OpcodeResolution, OpcodeNotSolvable, OpcodeResolutionError};
 
@@ -26,7 +25,7 @@ pub enum MulTerm {
 impl ArithmeticSolver {
     /// Derives the rest of the witness based on the initial low level variables
     pub fn solve(
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         gate: &Expression,
     ) -> Result<OpcodeResolution, OpcodeResolutionError> {
         let gate = &ArithmeticSolver::evaluate(gate, initial_witness);
@@ -120,10 +119,7 @@ impl ArithmeticSolver {
     /// If the witness values are not known, then the function returns a None
     /// XXX: Do we need to account for the case where 5xy + 6x = 0 ? We do not know y, but it can be solved given x . But I believe x can be solved with another gate
     /// XXX: What about making a mul gate = a constant 5xy + 7 = 0 ? This is the same as the above.
-    fn solve_mul_term(
-        arith_gate: &Expression,
-        witness_assignments: &BTreeMap<Witness, FieldElement>,
-    ) -> MulTerm {
+    fn solve_mul_term(arith_gate: &Expression, witness_assignments: &WitnessMap) -> MulTerm {
         // First note that the mul term can only contain one/zero term
         // We are assuming it has been optimized.
         match arith_gate.mul_terms.len() {
@@ -138,7 +134,7 @@ impl ArithmeticSolver {
 
     fn solve_mul_term_helper(
         term: &(FieldElement, Witness, Witness),
-        witness_assignments: &BTreeMap<Witness, FieldElement>,
+        witness_assignments: &WitnessMap,
     ) -> MulTerm {
         let (q_m, w_l, w_r) = term;
         // Check if these values are in the witness assignments
@@ -155,7 +151,7 @@ impl ArithmeticSolver {
 
     fn solve_fan_in_term_helper(
         term: &(FieldElement, Witness),
-        witness_assignments: &BTreeMap<Witness, FieldElement>,
+        witness_assignments: &WitnessMap,
     ) -> Option<FieldElement> {
         let (q_l, w_l) = term;
         // Check if we have w_l
@@ -168,7 +164,7 @@ impl ArithmeticSolver {
     /// We cannot assign
     pub fn solve_fan_in_term(
         arith_gate: &Expression,
-        witness_assignments: &BTreeMap<Witness, FieldElement>,
+        witness_assignments: &WitnessMap,
     ) -> GateStatus {
         // This is assuming that the fan-in is more than 0
 
@@ -202,10 +198,7 @@ impl ArithmeticSolver {
     }
 
     // Partially evaluate the gate using the known witnesses
-    pub fn evaluate(
-        expr: &Expression,
-        initial_witness: &BTreeMap<Witness, FieldElement>,
-    ) -> Expression {
+    pub fn evaluate(expr: &Expression, initial_witness: &WitnessMap) -> Expression {
         let mut result = Expression::default();
         for &(c, w1, w2) in &expr.mul_terms {
             let mul_result = ArithmeticSolver::solve_mul_term_helper(&(c, w1, w2), initial_witness);
@@ -280,7 +273,7 @@ fn arithmetic_smoke_test() {
         q_c: FieldElement::zero(),
     };
 
-    let mut values: BTreeMap<Witness, FieldElement> = BTreeMap::new();
+    let mut values = WitnessMap::new();
     values.insert(b, FieldElement::from(2_i128));
     values.insert(c, FieldElement::from(1_i128));
     values.insert(d, FieldElement::from(1_i128));
diff --git a/acvm/src/pwg/blackbox.rs b/acvm/src/pwg/blackbox.rs
index 9b17e5305..aa887b9c6 100644
--- a/acvm/src/pwg/blackbox.rs
+++ b/acvm/src/pwg/blackbox.rs
@@ -1,9 +1,6 @@
-use std::collections::BTreeMap;
-
 use acir::{
     circuit::opcodes::{BlackBoxFuncCall, FunctionInput},
-    native_types::Witness,
-    FieldElement,
+    native_types::{Witness, WitnessMap},
 };
 
 use crate::{OpcodeNotSolvable, OpcodeResolutionError, PartialWitnessGenerator};
@@ -14,7 +11,7 @@ use super::OpcodeResolution;
 ///
 /// Returns the first missing assignment if any are missing
 fn first_missing_assignment(
-    witness_assignments: &BTreeMap<Witness, FieldElement>,
+    witness_assignments: &WitnessMap,
     inputs: &[FunctionInput],
 ) -> Option<Witness> {
     inputs.iter().find_map(|input| {
@@ -27,16 +24,13 @@ fn first_missing_assignment(
 }
 
 /// Check if all of the inputs to the function have assignments
-fn contains_all_inputs(
-    witness_assignments: &BTreeMap<Witness, FieldElement>,
-    inputs: &[FunctionInput],
-) -> bool {
+fn contains_all_inputs(witness_assignments: &WitnessMap, inputs: &[FunctionInput]) -> bool {
     inputs.iter().all(|input| witness_assignments.contains_key(&input.witness))
 }
 
 pub(crate) fn solve(
     backend: &impl PartialWitnessGenerator,
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
     bb_func: &BlackBoxFuncCall,
 ) -> Result<OpcodeResolution, OpcodeResolutionError> {
     let inputs = bb_func.get_inputs_vec();
diff --git a/acvm/src/pwg/block.rs b/acvm/src/pwg/block.rs
index e2d63567d..4389c67e4 100644
--- a/acvm/src/pwg/block.rs
+++ b/acvm/src/pwg/block.rs
@@ -1,8 +1,8 @@
-use std::collections::{BTreeMap, HashMap};
+use std::collections::HashMap;
 
 use acir::{
     circuit::opcodes::{BlockId, MemOp},
-    native_types::Witness,
+    native_types::{Witness, WitnessMap},
     FieldElement,
 };
 
@@ -24,7 +24,7 @@ impl Blocks {
         &mut self,
         id: BlockId,
         trace: &[MemOp],
-        solved_witness: &mut BTreeMap<Witness, FieldElement>,
+        solved_witness: &mut WitnessMap,
     ) -> Result<OpcodeResolution, OpcodeResolutionError> {
         let solver = self.blocks.entry(id).or_default();
         solver.solve(solved_witness, trace)
@@ -54,7 +54,7 @@ impl BlockSolver {
     // We stop when an operation cannot be resolved
     fn solve_helper(
         &mut self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         trace: &[MemOp],
     ) -> Result<(), OpcodeResolutionError> {
         let missing_assignment = |witness: Option<Witness>| {
@@ -102,7 +102,7 @@ impl BlockSolver {
     // and converts its result into GateResolution
     pub(crate) fn solve(
         &mut self,
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         trace: &[MemOp],
     ) -> Result<OpcodeResolution, OpcodeResolutionError> {
         let initial_solved_operations = self.solved_operations;
@@ -123,11 +123,9 @@ impl BlockSolver {
 
 #[cfg(test)]
 mod test {
-    use std::collections::BTreeMap;
-
     use acir::{
         circuit::opcodes::{BlockId, MemOp},
-        native_types::{Expression, Witness},
+        native_types::{Expression, Witness, WitnessMap},
         FieldElement,
     };
 
@@ -161,7 +159,7 @@ mod test {
             value: Expression::from(Witness(4)),
         });
         let id = BlockId::default();
-        let mut initial_witness = BTreeMap::new();
+        let mut initial_witness = WitnessMap::new();
         let mut value = FieldElement::zero();
         insert_value(&Witness(1), value, &mut initial_witness).unwrap();
         value = FieldElement::one();
diff --git a/acvm/src/pwg/directives.rs b/acvm/src/pwg/directives.rs
index 7240997d7..9b18bf7d4 100644
--- a/acvm/src/pwg/directives.rs
+++ b/acvm/src/pwg/directives.rs
@@ -1,8 +1,8 @@
-use std::{cmp::Ordering, collections::BTreeMap};
+use std::cmp::Ordering;
 
 use acir::{
     circuit::directives::{Directive, LogInfo, QuotientDirective},
-    native_types::Witness,
+    native_types::WitnessMap,
     FieldElement,
 };
 use num_bigint::BigUint;
@@ -19,7 +19,7 @@ use super::{get_value, insert_value, sorting::route, witness_to_value};
 ///
 /// Returns `Err(OpcodeResolutionError)` if a circuit constraint is unsatisfied.
 pub fn solve_directives(
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
     directive: &Directive,
 ) -> Result<OpcodeResolution, OpcodeResolutionError> {
     match solve_directives_internal(initial_witness, directive) {
@@ -32,7 +32,7 @@ pub fn solve_directives(
 }
 
 fn solve_directives_internal(
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
     directive: &Directive,
 ) -> Result<(), OpcodeResolutionError> {
     match directive {
diff --git a/acvm/src/pwg/hash.rs b/acvm/src/pwg/hash.rs
index 4d630935e..208626e1b 100644
--- a/acvm/src/pwg/hash.rs
+++ b/acvm/src/pwg/hash.rs
@@ -1,15 +1,18 @@
-use acir::{circuit::opcodes::FunctionInput, native_types::Witness, FieldElement};
+use acir::{
+    circuit::opcodes::FunctionInput,
+    native_types::{Witness, WitnessMap},
+    FieldElement,
+};
 use blake2::{Blake2s256, Digest};
 use sha2::Sha256;
 use sha3::Keccak256;
-use std::collections::BTreeMap;
 
 use crate::{pwg::OpcodeResolution, OpcodeResolutionError};
 
 use super::{insert_value, witness_to_value};
 
 pub fn blake2s256(
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
     inputs: &[FunctionInput],
     outputs: &[Witness],
 ) -> Result<OpcodeResolution, OpcodeResolutionError> {
@@ -27,7 +30,7 @@ pub fn blake2s256(
 }
 
 pub fn sha256(
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
     inputs: &[FunctionInput],
     outputs: &[Witness],
 ) -> Result<OpcodeResolution, OpcodeResolutionError> {
@@ -45,7 +48,7 @@ pub fn sha256(
 }
 
 pub fn keccak256(
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
     inputs: &[FunctionInput],
     outputs: &[Witness],
 ) -> Result<OpcodeResolution, OpcodeResolutionError> {
@@ -63,7 +66,7 @@ pub fn keccak256(
 }
 
 pub fn hash_to_field_128_security(
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
     inputs: &[FunctionInput],
     output: &Witness,
 ) -> Result<OpcodeResolution, OpcodeResolutionError> {
@@ -76,7 +79,7 @@ pub fn hash_to_field_128_security(
 }
 
 fn generic_hash_256<D: Digest>(
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
     inputs: &[FunctionInput],
 ) -> Result<[u8; 32], OpcodeResolutionError> {
     let mut hasher = D::new();
diff --git a/acvm/src/pwg/logic.rs b/acvm/src/pwg/logic.rs
index acab1b17b..98c019414 100644
--- a/acvm/src/pwg/logic.rs
+++ b/acvm/src/pwg/logic.rs
@@ -1,12 +1,15 @@
 use super::{insert_value, witness_to_value};
 use crate::{pwg::OpcodeResolution, OpcodeResolutionError};
-use acir::{circuit::opcodes::FunctionInput, native_types::Witness, FieldElement};
-use std::collections::BTreeMap;
+use acir::{
+    circuit::opcodes::FunctionInput,
+    native_types::{Witness, WitnessMap},
+    FieldElement,
+};
 
 /// Solves a [`BlackBoxFunc::And`][acir::circuit::black_box_functions::BlackBoxFunc::AND] opcode and inserts
 /// the result into the supplied witness map
 pub fn and(
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
     lhs: &FunctionInput,
     rhs: &FunctionInput,
     output: &Witness,
@@ -23,7 +26,7 @@ pub fn and(
 /// Solves a [`BlackBoxFunc::XOR`][acir::circuit::black_box_functions::BlackBoxFunc::XOR] opcode and inserts
 /// the result into the supplied witness map
 pub fn xor(
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
     lhs: &FunctionInput,
     rhs: &FunctionInput,
     output: &Witness,
@@ -39,7 +42,7 @@ pub fn xor(
 
 /// Derives the rest of the witness based on the initial low level variables
 fn solve_logic_gate(
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
     a: &Witness,
     b: &Witness,
     result: Witness,
diff --git a/acvm/src/pwg/oracle.rs b/acvm/src/pwg/oracle.rs
index b13949fff..0d2e6cc87 100644
--- a/acvm/src/pwg/oracle.rs
+++ b/acvm/src/pwg/oracle.rs
@@ -1,6 +1,4 @@
-use std::collections::BTreeMap;
-
-use acir::{circuit::opcodes::OracleData, native_types::Witness, FieldElement};
+use acir::{circuit::opcodes::OracleData, native_types::WitnessMap};
 
 use crate::{pwg::OpcodeResolution, OpcodeNotSolvable, OpcodeResolutionError};
 
@@ -11,7 +9,7 @@ pub struct OracleSolver;
 impl OracleSolver {
     /// Derives the rest of the witness based on the initial low level variables
     pub fn solve(
-        initial_witness: &mut BTreeMap<Witness, FieldElement>,
+        initial_witness: &mut WitnessMap,
         data: &mut OracleData,
     ) -> Result<OpcodeResolution, OpcodeResolutionError> {
         // Set input values
diff --git a/acvm/src/pwg/range.rs b/acvm/src/pwg/range.rs
index 8770993d0..c2ebd48f5 100644
--- a/acvm/src/pwg/range.rs
+++ b/acvm/src/pwg/range.rs
@@ -1,9 +1,8 @@
 use crate::{pwg::witness_to_value, pwg::OpcodeResolution, OpcodeResolutionError};
-use acir::{circuit::opcodes::FunctionInput, native_types::Witness, FieldElement};
-use std::collections::BTreeMap;
+use acir::{circuit::opcodes::FunctionInput, native_types::WitnessMap};
 
 pub fn solve_range_opcode(
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
     input: &FunctionInput,
 ) -> Result<OpcodeResolution, OpcodeResolutionError> {
     let w_value = witness_to_value(initial_witness, input.witness)?;
diff --git a/acvm/src/pwg/signature/ecdsa.rs b/acvm/src/pwg/signature/ecdsa.rs
index 2106fae2e..9dc0e522c 100644
--- a/acvm/src/pwg/signature/ecdsa.rs
+++ b/acvm/src/pwg/signature/ecdsa.rs
@@ -1,10 +1,13 @@
-use acir::{circuit::opcodes::FunctionInput, native_types::Witness, FieldElement};
-use std::collections::BTreeMap;
+use acir::{
+    circuit::opcodes::FunctionInput,
+    native_types::{Witness, WitnessMap},
+    FieldElement,
+};
 
 use crate::{pwg::witness_to_value, pwg::OpcodeResolution, OpcodeResolutionError};
 
 fn to_u8_vec(
-    initial_witness: &BTreeMap<Witness, FieldElement>,
+    initial_witness: &WitnessMap,
     inputs: &[FunctionInput],
 ) -> Result<Vec<u8>, OpcodeResolutionError> {
     let mut result = Vec::with_capacity(inputs.len());
@@ -17,7 +20,7 @@ fn to_u8_vec(
 }
 
 pub fn secp256k1_prehashed(
-    initial_witness: &mut BTreeMap<Witness, FieldElement>,
+    initial_witness: &mut WitnessMap,
     public_key_x_inputs: &[FunctionInput],
     public_key_y_inputs: &[FunctionInput],
     signature_inputs: &[FunctionInput],