diff --git a/noir_stdlib/src/bigint.nr b/noir_stdlib/src/bigint.nr
index 11026651207..61051da7116 100644
--- a/noir_stdlib/src/bigint.nr
+++ b/noir_stdlib/src/bigint.nr
@@ -1,5 +1,5 @@
-use crate::ops::{Add, Sub, Mul, Div, Rem,};
-
+use crate::ops::{Add, Sub, Mul, Div};
+use crate::cmp::Eq;
 
 global bn254_fq = [0x47, 0xFD, 0x7C, 0xD8, 0x16, 0x8C, 0x20, 0x3C, 0x8d, 0xca, 0x71, 0x68, 0x91, 0x6a, 0x81, 0x97,
                    0x5d, 0x58, 0x81, 0x81, 0xb6, 0x45, 0x50, 0xb8, 0x29, 0xa0, 0x31, 0xe1, 0x72, 0x4e, 0x64, 0x30];
@@ -36,46 +36,321 @@ impl BigInt {
     #[builtin(bigint_from_le_bytes)]
     fn from_le_bytes(bytes: [u8], modulus: [u8]) -> BigInt {}
     #[builtin(bigint_to_le_bytes)]
-    pub fn to_le_bytes(self) -> [u8] {}
+    fn to_le_bytes(self) -> [u8] {}
 
-    pub fn bn254_fr_from_le_bytes(bytes: [u8]) -> BigInt {
-        BigInt::from_le_bytes(bytes, bn254_fr)
+    fn check_32_bytes(self: Self, other: BigInt) -> bool {
+        let bytes = self.to_le_bytes();
+        let o_bytes = other.to_le_bytes();
+        let mut result = true;
+        for i in 0..32{
+            result = result & (bytes[i] == o_bytes[i]);
+        }
+        result
     }
-    pub fn bn254_fq_from_le_bytes(bytes: [u8]) -> BigInt {
-        BigInt::from_le_bytes(bytes, bn254_fq)
+}
+
+
+trait BigField {
+    fn from_le_bytes(bytes: [u8]) -> Self;
+    fn to_le_bytes(self) -> [u8];
+}
+
+struct Secpk1Fq {
+    inner: BigInt,
+}
+
+impl BigField for Secpk1Fq {
+    fn from_le_bytes(bytes: [u8]) -> Secpk1Fq {
+        Secpk1Fq {
+            inner: BigInt::from_le_bytes(bytes, secpk1_fq)
+        }
+    }
+    fn to_le_bytes(self) -> [u8] {
+        self.inner.to_le_bytes()
     }
-    pub fn secpk1_fq_from_le_bytes(bytes: [u8]) -> BigInt {
-        BigInt::from_le_bytes(bytes, secpk1_fq)
+}
+
+impl Add for Secpk1Fq { 
+    fn add(self: Self, other: Secpk1Fq) -> Secpk1Fq {
+        Secpk1Fq {
+            inner: self.inner.bigint_add(other.inner)
+        }
     }
-    pub fn secpk1_fr_from_le_bytes(bytes: [u8]) -> BigInt {
-        BigInt::from_le_bytes(bytes, secpk1_fr)
+}
+impl Sub for Secpk1Fq { 
+    fn sub(self: Self, other: Secpk1Fq) -> Secpk1Fq {
+        Secpk1Fq {
+            inner: self.inner.bigint_sub(other.inner)
+        }
     }
 }
+impl Mul for Secpk1Fq { 
+    fn mul(self: Self, other: Secpk1Fq) -> Secpk1Fq {
+        Secpk1Fq {
+            inner: self.inner.bigint_mul(other.inner)
+        }
 
-impl Add for BigInt { 
-    fn add(self: Self, other: BigInt) -> BigInt {
-        self.bigint_add(other)
     }
 }
-impl Sub for BigInt { 
-    fn sub(self: Self, other: BigInt) -> BigInt {
-        self.bigint_sub(other)
+impl Div for Secpk1Fq { 
+    fn div(self: Self, other: Secpk1Fq) -> Secpk1Fq {
+        Secpk1Fq {
+            inner: self.inner.bigint_div(other.inner)
+        }
     }
 }
-impl Mul for BigInt { 
-    fn mul(self: Self, other: BigInt) -> BigInt {
-        self.bigint_mul(other)
+impl Eq for Secpk1Fq {
+    fn eq(self: Self, other: Secpk1Fq) -> bool {
+        self.inner.check_32_bytes(other.inner)
     }
 }
-impl Div for BigInt { 
-    fn div(self: Self, other: BigInt) -> BigInt {
-        self.bigint_div(other)
+
+struct Secpk1Fr {
+    inner: BigInt,
+}
+
+impl BigField for Secpk1Fr {
+    fn from_le_bytes(bytes: [u8]) -> Secpk1Fr {
+        Secpk1Fr {
+            inner: BigInt::from_le_bytes(bytes, secpk1_fr)
+        }
+    }
+    fn to_le_bytes(self) -> [u8] {
+        self.inner.to_le_bytes()
+    }
+}
+
+impl Add for Secpk1Fr { 
+    fn add(self: Self, other: Secpk1Fr) -> Secpk1Fr {
+        Secpk1Fr {
+            inner: self.inner.bigint_add(other.inner)
+        }
     }
 }
-impl Rem for BigInt { 
-    fn rem(self: Self, other: BigInt) -> BigInt {
-        let quotient = self.bigint_div(other);
-        self.bigint_sub(quotient.bigint_mul(other))
+impl Sub for Secpk1Fr { 
+    fn sub(self: Self, other: Secpk1Fr) -> Secpk1Fr {
+        Secpk1Fr {
+            inner: self.inner.bigint_sub(other.inner)
+        }
     }
 }
+impl Mul for Secpk1Fr { 
+    fn mul(self: Self, other: Secpk1Fr) -> Secpk1Fr {
+        Secpk1Fr {
+            inner: self.inner.bigint_mul(other.inner)
+        }
 
+    }
+}
+impl Div for Secpk1Fr { 
+    fn div(self: Self, other: Secpk1Fr) -> Secpk1Fr {
+        Secpk1Fr {
+            inner: self.inner.bigint_div(other.inner)
+        }
+    }
+}
+impl Eq for Secpk1Fr {
+    fn eq(self: Self, other: Secpk1Fr) -> bool {
+        self.inner.check_32_bytes(other.inner)
+    }
+}
+
+struct Bn254Fr {
+    inner: BigInt,
+}
+
+impl BigField for Bn254Fr {
+    fn from_le_bytes(bytes: [u8]) -> Bn254Fr {
+        Bn254Fr {
+            inner: BigInt::from_le_bytes(bytes, bn254_fr)
+        }
+    }
+    fn to_le_bytes(self) -> [u8] {
+        self.inner.to_le_bytes()
+    }
+}
+
+impl Add for Bn254Fr { 
+    fn add(self: Self, other: Bn254Fr) -> Bn254Fr {
+        Bn254Fr {
+            inner: self.inner.bigint_add(other.inner)
+        }
+    }
+}
+impl Sub for Bn254Fr { 
+    fn sub(self: Self, other: Bn254Fr) -> Bn254Fr {
+        Bn254Fr {
+            inner: self.inner.bigint_sub(other.inner)
+        }
+    }
+}
+impl Mul for Bn254Fr { 
+    fn mul(self: Self, other: Bn254Fr) -> Bn254Fr {
+        Bn254Fr {
+            inner: self.inner.bigint_mul(other.inner)
+        }
+
+    }
+}
+impl Div for Bn254Fr { 
+    fn div(self: Self, other: Bn254Fr) -> Bn254Fr {
+        Bn254Fr {
+            inner: self.inner.bigint_div(other.inner)
+        }
+    }
+}
+impl Eq for Bn254Fr {
+    fn eq(self: Self, other: Bn254Fr) -> bool {
+        self.inner.check_32_bytes(other.inner)
+    }
+}
+
+struct Bn254Fq {
+    inner: BigInt,
+}
+
+impl BigField for Bn254Fq {
+    fn from_le_bytes(bytes: [u8]) -> Bn254Fq {
+        Bn254Fq {
+            inner: BigInt::from_le_bytes(bytes, bn254_fq)
+        }
+    }
+    fn to_le_bytes(self) -> [u8] {
+        self.inner.to_le_bytes()
+    }
+}
+
+impl Add for Bn254Fq { 
+    fn add(self: Self, other: Bn254Fq) -> Bn254Fq {
+        Bn254Fq {
+            inner: self.inner.bigint_add(other.inner)
+        }
+    }
+}
+impl Sub for Bn254Fq { 
+    fn sub(self: Self, other: Bn254Fq) -> Bn254Fq {
+        Bn254Fq {
+            inner: self.inner.bigint_sub(other.inner)
+        }
+    }
+}
+impl Mul for Bn254Fq { 
+    fn mul(self: Self, other: Bn254Fq) -> Bn254Fq {
+        Bn254Fq {
+            inner: self.inner.bigint_mul(other.inner)
+        }
+
+    }
+}
+impl Div for Bn254Fq { 
+    fn div(self: Self, other: Bn254Fq) -> Bn254Fq {
+        Bn254Fq {
+            inner: self.inner.bigint_div(other.inner)
+        }
+    }
+}
+impl Eq for Bn254Fq {
+    fn eq(self: Self, other: Bn254Fq) -> bool {
+        self.inner.check_32_bytes(other.inner)
+    }
+}
+
+struct Secpr1Fq {
+    inner: BigInt,
+}
+
+impl BigField for Secpr1Fq {
+    fn from_le_bytes(bytes: [u8]) -> Secpr1Fq {
+        Secpr1Fq {
+            inner: BigInt::from_le_bytes(bytes, secpr1_fq)
+        }
+    }
+    fn to_le_bytes(self) -> [u8] {
+        self.inner.to_le_bytes()
+    }
+}
+
+impl Add for Secpr1Fq { 
+    fn add(self: Self, other: Secpr1Fq) -> Secpr1Fq {
+        Secpr1Fq {
+            inner: self.inner.bigint_add(other.inner)
+        }
+    }
+}
+impl Sub for Secpr1Fq { 
+    fn sub(self: Self, other: Secpr1Fq) -> Secpr1Fq {
+        Secpr1Fq {
+            inner: self.inner.bigint_sub(other.inner)
+        }
+    }
+}
+impl Mul for Secpr1Fq { 
+    fn mul(self: Self, other: Secpr1Fq) -> Secpr1Fq {
+        Secpr1Fq {
+            inner: self.inner.bigint_mul(other.inner)
+        }
+
+    }
+}
+impl Div for Secpr1Fq { 
+    fn div(self: Self, other: Secpr1Fq) -> Secpr1Fq {
+        Secpr1Fq {
+            inner: self.inner.bigint_div(other.inner)
+        }
+    }
+}
+impl Eq for Secpr1Fq {
+    fn eq(self: Self, other: Secpr1Fq) -> bool {
+        self.inner.check_32_bytes(other.inner)
+    }
+}
+
+struct Secpr1Fr {
+    inner: BigInt,
+}
+
+impl BigField for Secpr1Fr {
+    fn from_le_bytes(bytes: [u8]) -> Secpr1Fr {
+        Secpr1Fr {
+            inner: BigInt::from_le_bytes(bytes, secpr1_fr)
+        }
+    }
+    fn to_le_bytes(self) -> [u8] {
+        self.inner.to_le_bytes()
+    }
+}
+
+impl Add for Secpr1Fr { 
+    fn add(self: Self, other: Secpr1Fr) -> Secpr1Fr {
+        Secpr1Fr {
+            inner: self.inner.bigint_add(other.inner)
+        }
+    }
+}
+impl Sub for Secpr1Fr { 
+    fn sub(self: Self, other: Secpr1Fr) -> Secpr1Fr {
+        Secpr1Fr {
+            inner: self.inner.bigint_sub(other.inner)
+        }
+    }
+}
+impl Mul for Secpr1Fr { 
+    fn mul(self: Self, other: Secpr1Fr) -> Secpr1Fr {
+        Secpr1Fr {
+            inner: self.inner.bigint_mul(other.inner)
+        }
+
+    }
+}
+impl Div for Secpr1Fr { 
+    fn div(self: Self, other: Secpr1Fr) -> Secpr1Fr {
+        Secpr1Fr {
+            inner: self.inner.bigint_div(other.inner)
+        }
+    }
+}
+impl Eq for Secpr1Fr {
+    fn eq(self: Self, other: Secpr1Fr) -> bool {
+        self.inner.check_32_bytes(other.inner)
+    }
+}
diff --git a/test_programs/execution_success/3_add/src/main.nr b/test_programs/execution_success/3_add/src/main.nr
index 480348dc1cf..9c77af868b6 100644
--- a/test_programs/execution_success/3_add/src/main.nr
+++ b/test_programs/execution_success/3_add/src/main.nr
@@ -5,4 +5,4 @@ fn main(mut x: u32, y: u32, z: u32) {
 
     x *= 8;
     assert(x > 9);
-}
+}
\ No newline at end of file
diff --git a/test_programs/execution_success/array_dynamic_blackbox_input/Nargo.toml b/test_programs/execution_success/array_dynamic_blackbox_input/Nargo.toml
deleted file mode 100644
index 15d437a8f8d..00000000000
--- a/test_programs/execution_success/array_dynamic_blackbox_input/Nargo.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-[package]
-name = "array_dynamic_blackbox_input"
-type = "bin"
-authors = [""]
-compiler_version = ">=0.23.0"
-
-[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/array_dynamic_blackbox_input/Prover.toml b/test_programs/execution_success/array_dynamic_blackbox_input/Prover.toml
deleted file mode 100644
index 3797c0b0038..00000000000
--- a/test_programs/execution_success/array_dynamic_blackbox_input/Prover.toml
+++ /dev/null
@@ -1,4 +0,0 @@
-index = "1"
-leaf = ["51", "109", "224", "175", "60", "42", "79", "222", "117", "255", "174", "79", "126", "242", "74", "34", "100", "35", "20", "200", "109", "89", "191", "219", "41", "10", "118", "217", "165", "224", "215", "109"]
-path = ["0", "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"]
-root = ["243", "212", "223", "132", "202", "119", "167", "60", "162", "158", "66", "192", "88", "114", "34", "191", "202", "195", "19", "102", "150", "88", "222", "176", "35", "51", "110", "97", "204", "224", "253", "171"]
diff --git a/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr b/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr
deleted file mode 100644
index aabf7fc9d5c..00000000000
--- a/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr
+++ /dev/null
@@ -1,27 +0,0 @@
-fn main(leaf: [u8; 32], path: [u8; 64], index: u32, root: [u8; 32]) {
-    compute_root(leaf, path, index, root);
-}
-
-fn compute_root(leaf: [u8; 32], path: [u8; 64], _index: u32, root: [u8; 32]) {
-    let mut current = leaf;
-    let mut index = _index;
-
-    for i in 0..2 {
-        let mut hash_input = [0; 64];
-        let offset = i * 32;
-        let is_right = (index & 1) != 0;
-        let a = if is_right { 32 } else { 0 };
-        let b = if is_right { 0 } else { 32 };
-
-        for j in 0..32 {
-            hash_input[j + a] = current[j];
-            hash_input[j + b] = path[offset + j];
-        }
-
-        current = dep::std::hash::sha256(hash_input);
-        index = index >> 1;
-    }
-
-    // Regression for issue #4258
-    assert(root == current);
-}
\ No newline at end of file
diff --git a/test_programs/execution_success/bigint/src/main.nr b/test_programs/execution_success/bigint/src/main.nr
index 74949a5f785..4b873506287 100644
--- a/test_programs/execution_success/bigint/src/main.nr
+++ b/test_programs/execution_success/bigint/src/main.nr
@@ -1,9 +1,8 @@
 use dep::std::bigint;
 
 fn main(mut x: [u8;5], y: [u8;5]) {
-    let a = bigint::BigInt::secpk1_fq_from_le_bytes([x[0],x[1],x[2],x[3],x[4]]);
-    let b = bigint::BigInt::secpk1_fq_from_le_bytes([y[0],y[1],y[2],y[3],y[4]]);
-
+    let a = bigint::Secpk1Fq::from_le_bytes([x[0],x[1],x[2],x[3],x[4]]);
+    let b = bigint::Secpk1Fq::from_le_bytes([y[0],y[1],y[2],y[3],y[4]]);
     let a_bytes = a.to_le_bytes();
     let b_bytes = b.to_le_bytes();
     for i in 0..5 {
@@ -12,10 +11,7 @@ fn main(mut x: [u8;5], y: [u8;5]) {
     }
 
     let d = a*b - b;
-    let d_bytes = d.to_le_bytes();
-    let d1 = bigint::BigInt::secpk1_fq_from_le_bytes(597243850900842442924.to_le_bytes(10));
-    let d1_bytes = d1.to_le_bytes();
-    for i in 0..32 {
-        assert(d_bytes[i] == d1_bytes[i]);    
-    }
+    let d1 = bigint::Secpk1Fq::from_le_bytes(597243850900842442924.to_le_bytes(10));
+    assert(d1 == d);
+
 }