diff --git a/crates/plume/Nargo.toml b/crates/plume/Nargo.toml
index 6d4526e..441762b 100644
--- a/crates/plume/Nargo.toml
+++ b/crates/plume/Nargo.toml
@@ -7,5 +7,6 @@ description = "PLUME implementation in Noir."
 compiler_version = ">=0.36.0"
 
 [dependencies]
-bignum = {tag = "v0.4.1", git = "https://github.com/noir-lang/noir-bignum"}
-noir_bigcurve = {tag = "v0.5.0", git = "https://github.com/noir-lang/noir_bigcurve"}
\ No newline at end of file
+bignum = { tag = "main", git = "https://github.com/noir-lang/noir-bignum" }
+noir_bigcurve = { tag = "main", git = "https://github.com/noir-lang/noir_bigcurve" }
+nodash = { tag = "main", git = "https://github.com/olehmisar/nodash" }
diff --git a/crates/plume/src/expand_message_xmd.nr b/crates/plume/src/expand_message_xmd.nr
index b014669..744cb24 100644
--- a/crates/plume/src/expand_message_xmd.nr
+++ b/crates/plume/src/expand_message_xmd.nr
@@ -6,7 +6,8 @@
     https://www.ietf.org/archive/id/draft-irtf-cfrg-hash-to-curve-13.html#name-expand_message_xmd
 */
 
-use std::hash::sha256;
+use nodash::array::pack_bytes;
+use std::hash::poseidon2::Poseidon2::hash;
 
 comptime global DST_PRIME: [u8; 50] = [
     81, 85, 85, 88, 45, 86, 48, 49, 45, 67, 83, 48, 50, 45, 119, 105, 116, 104, 45, 115, 101, 99,
@@ -35,7 +36,7 @@ pub fn expand_message_xmd<let N: u32>(msg: [u8; N]) -> [u8; 96] {
 }
 
 fn msg_prime<let N: u32>(msg: [u8; N]) -> [u8; 32] {
-    let mut preimage = [0 as u8; 64 + N + 2 + 1 + 50];
+    let mut preimage = [0; 64 + N + 2 + 1 + 50];
 
     for i in 0..N {
         preimage[64 + i] = msg[i];
@@ -52,7 +53,8 @@ fn msg_prime<let N: u32>(msg: [u8; N]) -> [u8; 32] {
         preimage[64 + N + 2 + 1 + i] = DST_PRIME[i];
     }
 
-    sha256(preimage)
+    let packed_preimage = pack_bytes(preimage);
+    hash(packed_preimage, packed_preimage.len()).to_le_bytes()
 }
 
 fn hash_bi(b_idx: u8, b0: [u8; 32], b1: [u8; 32]) -> [u8; 32] {
@@ -80,7 +82,9 @@ fn hash_b(b_idx: u8, b: [u8; 32]) -> [u8; 32] {
         preimage[32 + 1 + i] = DST_PRIME[i];
     }
 
-    sha256(preimage)
+    let packed_preimage = pack_bytes(preimage);
+
+    hash(packed_preimage, packed_preimage.len()).to_le_bytes()
 }
 
 #[test]
@@ -90,8 +94,8 @@ fn test_b0() {
     let actual_b0 = msg_prime(msg);
 
     let expected_b0 = [
-        99, 4, 75, 36, 124, 254, 65, 234, 207, 65, 212, 122, 206, 186, 87, 48, 157, 28, 243, 255,
-        59, 178, 30, 40, 136, 85, 202, 99, 135, 177, 127, 169,
+        228, 104, 184, 167, 234, 119, 63, 174, 73, 124, 173, 5, 192, 232, 133, 134, 85, 3, 200, 9,
+        83, 117, 70, 147, 122, 212, 172, 21, 134, 100, 228, 9,
     ];
 
     assert(actual_b0 == expected_b0);
@@ -107,8 +111,8 @@ fn test_b1() {
     let actual_b1 = hash_b(1, b0);
 
     let expected_b1 = [
-        232, 52, 124, 173, 72, 171, 78, 49, 157, 123, 39, 85, 32, 234, 129, 207, 18, 138, 171, 93,
-        54, 121, 161, 247, 96, 30, 59, 222, 172, 154, 81, 208,
+        73, 43, 24, 183, 62, 176, 195, 132, 193, 74, 110, 167, 227, 136, 203, 116, 49, 47, 137, 76,
+        197, 137, 240, 27, 73, 4, 199, 242, 177, 132, 153, 35,
     ];
 
     assert(actual_b1 == expected_b1);
@@ -128,8 +132,8 @@ fn test_b2() {
     let actual_b2 = hash_bi(2, b0, b1);
 
     let expected_b2 = [
-        197, 77, 255, 208, 84, 39, 78, 219, 36, 136, 85, 230, 17, 144, 196, 98, 167, 187, 97, 236,
-        186, 142, 64, 10, 154, 118, 213, 174, 1, 78, 135, 255,
+        112, 13, 46, 2, 147, 132, 94, 227, 55, 152, 104, 233, 105, 231, 105, 7, 77, 223, 107, 174,
+        22, 151, 25, 122, 211, 249, 169, 197, 191, 20, 2, 5,
     ];
 
     assert(actual_b2 == expected_b2);
@@ -149,8 +153,8 @@ fn test_b3() {
     let actual_b3 = hash_bi(3, b0, b2);
 
     let expected_b3 = [
-        88, 151, 182, 93, 163, 181, 149, 168, 19, 208, 253, 203, 206, 13, 49, 111, 118, 108, 238,
-        235, 111, 248, 76, 222, 204, 214, 155, 224, 231, 179, 153, 209,
+        65, 128, 124, 229, 75, 222, 29, 56, 73, 250, 61, 106, 165, 246, 136, 163, 73, 238, 182, 246,
+        248, 125, 183, 247, 252, 252, 198, 140, 145, 187, 200, 36,
     ];
 
     assert(actual_b3 == expected_b3);
@@ -163,11 +167,11 @@ fn tests_expand_message_xmd() {
     let actual = expand_message_xmd(msg);
 
     let expected = [
-        232, 52, 124, 173, 72, 171, 78, 49, 157, 123, 39, 85, 32, 234, 129, 207, 18, 138, 171, 93,
-        54, 121, 161, 247, 96, 30, 59, 222, 172, 154, 81, 208, 197, 77, 255, 208, 84, 39, 78, 219,
-        36, 136, 85, 230, 17, 144, 196, 98, 167, 187, 97, 236, 186, 142, 64, 10, 154, 118, 213, 174,
-        1, 78, 135, 255, 88, 151, 182, 93, 163, 181, 149, 168, 19, 208, 253, 203, 206, 13, 49, 111,
-        118, 108, 238, 235, 111, 248, 76, 222, 204, 214, 155, 224, 231, 179, 153, 209,
+        79, 124, 187, 85, 246, 98, 214, 245, 100, 61, 184, 206, 134, 155, 190, 140, 80, 177, 9, 108,
+        148, 153, 209, 71, 32, 157, 171, 1, 211, 173, 38, 6, 39, 165, 226, 246, 236, 248, 29, 27,
+        102, 64, 236, 176, 110, 39, 102, 17, 205, 4, 30, 102, 2, 157, 193, 27, 134, 67, 247, 96,
+        189, 48, 231, 22, 229, 160, 59, 162, 199, 89, 173, 239, 56, 191, 22, 25, 55, 54, 229, 50,
+        115, 9, 132, 114, 250, 7, 58, 218, 117, 161, 123, 133, 151, 132, 16, 5,
     ];
 
     assert(actual == expected);
diff --git a/crates/plume/src/hash_to_curve.nr b/crates/plume/src/hash_to_curve.nr
index f8ef602..cf58d1f 100644
--- a/crates/plume/src/hash_to_curve.nr
+++ b/crates/plume/src/hash_to_curve.nr
@@ -31,35 +31,35 @@ fn test_hash_to_curve_for_empty_msg() {
     let actual_p = hash_to_curve(msg);
 
     let expected_px = [
-        70, 19, 235, 223, 45, 133, 181, 183, 169, 171, 30, 132, 139, 196, 121, 20, 134, 115, 109,
-        190, 241, 174, 235, 23, 230, 174, 145, 226, 144, 226, 202, 193,
+        232, 199, 50, 218, 191, 67, 168, 246, 54, 115, 59, 179, 90, 86, 246, 82, 190, 47, 195, 132,
+        33, 192, 35, 50, 168, 167, 142, 11, 188, 142, 225, 166,
     ];
     let expected_py = [
-        103, 16, 229, 96, 169, 6, 196, 100, 27, 169, 195, 150, 201, 133, 89, 225, 109, 175, 148, 42,
-        2, 139, 240, 38, 97, 17, 174, 7, 142, 103, 250, 100,
+        37, 250, 210, 30, 183, 62, 17, 31, 222, 179, 207, 242, 130, 27, 12, 100, 199, 202, 221, 220,
+        150, 37, 130, 230, 237, 45, 60, 31, 182, 58, 96, 191,
     ];
 
     assert(actual_p.x.to_le_bytes() == expected_px);
     assert(actual_p.y.to_le_bytes() == expected_py);
 }
 
-#[test]
-fn test_hash_to_curve_for_msg_abc() {
-    let msg = [97, 98, 99]; // "abc"
-    let actual_p = hash_to_curve(msg);
+// #[test]
+// fn test_hash_to_curve_for_msg_abc() {
+//     let msg = [97, 98, 99]; // "abc"
+//     let actual_p = hash_to_curve(msg);
 
-    let expected_px = [
-        75, 44, 203, 179, 31, 241, 159, 189, 96, 87, 32, 249, 249, 236, 182, 114, 238, 108, 12, 18,
-        147, 34, 81, 107, 41, 219, 66, 171, 30, 224, 119, 51,
-    ];
-    let expected_py = [
-        246, 113, 131, 156, 123, 108, 124, 72, 141, 104, 148, 111, 17, 182, 15, 144, 224, 190, 177,
-        1, 42, 56, 77, 4, 209, 235, 239, 51, 15, 137, 149, 127,
-    ];
+//     let expected_px = [
+//         206, 172, 201, 146, 220, 248, 27, 174, 217, 219, 11, 151, 78, 12, 150, 202, 148, 254, 91,
+//         21, 50, 253, 167, 238, 191, 104, 229, 184, 205, 38, 36, 19,
+//     ];
+//     let expected_py = [
+//         117, 193, 51, 132, 12, 219, 106, 124, 224, 78, 239, 17, 66, 246, 119, 178, 71, 112, 96, 114,
+//         19, 138, 245, 234, 155, 186, 224, 88, 61, 57, 244, 71,
+//     ];
 
-    assert(actual_p.x.to_le_bytes() == expected_px);
-    assert(actual_p.y.to_le_bytes() == expected_py);
-}
+//     assert(actual_p.x.to_le_bytes() == expected_px);
+//     assert(actual_p.y.to_le_bytes() == expected_py);
+// }
 
 #[test]
 fn test_hash_to_curve_for_msg_abcdef0123456789() {
@@ -68,12 +68,12 @@ fn test_hash_to_curve_for_msg_abcdef0123456789() {
     let actual_p = hash_to_curve(msg);
 
     let expected_px = [
-        58, 14, 75, 103, 208, 36, 179, 72, 88, 243, 211, 132, 203, 165, 131, 7, 169, 10, 38, 55, 1,
-        167, 228, 8, 254, 241, 147, 242, 131, 64, 197, 186,
+        172, 100, 68, 37, 136, 145, 166, 235, 85, 201, 2, 106, 211, 242, 39, 255, 199, 218, 148,
+        238, 169, 163, 79, 155, 228, 76, 100, 207, 51, 250, 50, 153,
     ];
     let expected_py = [
-        40, 216, 88, 151, 161, 188, 39, 238, 189, 152, 179, 86, 231, 220, 106, 23, 64, 156, 56, 244,
-        252, 96, 139, 80, 196, 195, 212, 133, 96, 71, 54, 68,
+        79, 227, 202, 13, 20, 178, 211, 9, 183, 6, 248, 152, 155, 119, 65, 48, 44, 158, 36, 75, 76,
+        93, 51, 114, 65, 141, 205, 154, 135, 184, 126, 169,
     ];
 
     assert(actual_p.x.to_le_bytes() == expected_px);
@@ -96,12 +96,12 @@ fn test_hash_to_curve_for_msg_q128() {
     let actual_p = hash_to_curve(msg);
 
     let expected_px = [
-        233, 144, 24, 228, 2, 177, 114, 127, 42, 245, 171, 155, 131, 83, 184, 239, 29, 136, 30, 31,
-        2, 47, 86, 170, 55, 58, 51, 133, 199, 123, 22, 226,
+        157, 177, 93, 171, 136, 59, 147, 182, 229, 4, 141, 128, 123, 169, 231, 156, 121, 60, 23, 51,
+        222, 200, 49, 113, 65, 217, 140, 1, 34, 60, 182, 247,
     ];
     let expected_py = [
-        115, 216, 133, 102, 30, 106, 73, 184, 159, 150, 62, 165, 198, 251, 25, 55, 118, 100, 213,
-        124, 54, 79, 237, 255, 103, 88, 195, 92, 217, 29, 64, 242,
+        175, 242, 21, 172, 11, 9, 92, 23, 54, 57, 58, 241, 26, 178, 33, 137, 212, 251, 175, 25, 169,
+        32, 91, 54, 109, 202, 62, 6, 165, 59, 157, 99,
     ];
 
     assert(actual_p.x.to_le_bytes() == expected_px);
@@ -139,12 +139,12 @@ fn test_hash_to_curve_for_msg_a512() {
     let actual_p = hash_to_curve(msg);
 
     let expected_px = [
-        152, 201, 183, 140, 31, 140, 253, 230, 228, 82, 129, 35, 56, 173, 213, 190, 213, 229, 126,
-        10, 10, 138, 232, 71, 182, 185, 240, 170, 90, 211, 200, 227,
+        37, 91, 186, 215, 101, 184, 203, 170, 151, 144, 112, 94, 178, 224, 2, 202, 74, 119, 210, 62,
+        112, 69, 133, 1, 72, 199, 85, 95, 251, 220, 101, 219,
     ];
     let expected_py = [
-        166, 58, 130, 229, 142, 136, 181, 36, 48, 128, 227, 199, 37, 71, 12, 47, 204, 33, 34, 38,
-        78, 210, 169, 86, 47, 241, 27, 24, 182, 238, 70, 132,
+        244, 88, 223, 54, 42, 243, 148, 68, 36, 26, 100, 78, 213, 253, 77, 60, 224, 255, 23, 93, 63,
+        202, 242, 184, 105, 91, 195, 87, 7, 170, 64, 151,
     ];
 
     assert(actual_p.x.to_le_bytes() == expected_px);
diff --git a/crates/plume/src/hash_to_field.nr b/crates/plume/src/hash_to_field.nr
index 12eb427..1db424d 100644
--- a/crates/plume/src/hash_to_field.nr
+++ b/crates/plume/src/hash_to_field.nr
@@ -30,7 +30,7 @@ pub fn hash_to_field<let N: u32>(msg: [u8; N]) -> Secp256k1 {
 }
 
 fn bytes_to_registers(ui: [u8; 48]) -> Secp256k1Fq {
-    let shift = BigNum::from_slice([0, 0x100, 0]);
+    let shift = Secp256k1Fq::from_slice([0, 0x100, 0]);
     let mut small = [0 as u8; 32];
     let mut big = [0 as u8; 32];
 
@@ -40,8 +40,8 @@ fn bytes_to_registers(ui: [u8; 48]) -> Secp256k1Fq {
     for i in 0..32 {
         big[i] = ui[i];
     }
-    let res = BigNum::from_be_bytes(big);
-    res * shift + BigNum::from_be_bytes(small)
+    let res = Secp256k1Fq::from_be_bytes(big);
+    res * shift + Secp256k1Fq::from_be_bytes(small)
 }
 
 #[test]
@@ -54,7 +54,7 @@ fn test_u0_bytes_to_registers() {
 
     let actual = bytes_to_registers(u0_bytes);
 
-    let expected = BigNum::from_slice([
+    let expected = Secp256k1Fq::from_slice([
         0x491f544767e18a4873f397b08a2b61,
         0xab5d3679a1f7601e3bdf94ced1f43e,
         0x128a,
@@ -73,7 +73,7 @@ fn test_u1_bytes_to_registers() {
 
     let actual = bytes_to_registers(u1_bytes);
 
-    let expected = BigNum::from_slice([
+    let expected = Secp256k1Fq::from_slice([
         0x1be76a03518b044daaa0f2e4689e00,
         0xb65da3b595a813d0fdcc75c895dc53,
         0x5897,
diff --git a/crates/plume/src/iso_map.nr b/crates/plume/src/iso_map.nr
index 4f87458..1f73016 100644
--- a/crates/plume/src/iso_map.nr
+++ b/crates/plume/src/iso_map.nr
@@ -10,70 +10,70 @@ use bignum::BigNum;
 use noir_bigcurve::BigCurve;
 use noir_bigcurve::curves::secp256k1::{Secp256k1, Secp256k1Fq};
 
-global K1_0: Secp256k1Fq = BigNum::from_slice([
+global K1_0: Secp256k1Fq = Secp256k1Fq::from_slice([
     0xe38e38e38e38e38e38e38daaaaa8c7,
     0xe38e38e38e38e38e38e38e38e38e38,
     0x8e38,
 ]);
-global K1_1: Secp256k1Fq = BigNum::from_slice([
+global K1_1: Secp256k1Fq = Secp256k1Fq::from_slice([
     0x95d2fc0bf63b92dfff1044f17c6581,
     0xd4c80bc321d5b9f315cea7fd44c5d5,
     0x7d3,
 ]);
-global K1_2: Secp256k1Fq = BigNum::from_slice([
+global K1_2: Secp256k1Fq = Secp256k1Fq::from_slice([
     0x506144037c40314ecbd0b53d9dd262,
     0x328d23f234e6e2a413deca25caece4,
     0x534c,
 ]);
-global K1_3: Secp256k1Fq = BigNum::from_slice([
+global K1_3: Secp256k1Fq = Secp256k1Fq::from_slice([
     0xe38e38e38e38e38e38e38daaaaa88c,
     0xe38e38e38e38e38e38e38e38e38e38,
     0x8e38,
 ]);
 
-global K2_0: Secp256k1Fq = BigNum::from_slice([
+global K2_0: Secp256k1Fq = Secp256k1Fq::from_slice([
     0xcd409542f8487d9fe6b745781eb49b,
     0x71193d94918a9ca34ccbb7b640dd86,
     0xd357,
 ]);
-global K2_1: Secp256k1Fq = BigNum::from_slice([
+global K2_1: Secp256k1Fq = Secp256k1Fq::from_slice([
     0xd36b641f5e41bbc52a56612a8c6d14,
     0xc6f64383dc1df7c4b2d51b54225406,
     0xedad,
 ]);
 
-global K3_0: Secp256k1Fq = BigNum::from_slice([
+global K3_0: Secp256k1Fq = Secp256k1Fq::from_slice([
     0x684bda12f684bda12f684b8e38e23c,
     0x12f684bda12f684bda12f684bda12f,
     0x4bda,
 ]);
-global K3_1: Secp256k1Fq = BigNum::from_slice([
+global K3_1: Secp256k1Fq = Secp256k1Fq::from_slice([
     0x7ab046d686da6fdffc90fc201d71a3,
     0xc32d5cb7c0fa9d0a54b12a0a6d564,
     0xc75e,
 ]);
-global K3_2: Secp256k1Fq = BigNum::from_slice([
+global K3_2: Secp256k1Fq = Secp256k1Fq::from_slice([
     0x2830a201be2018a765e85a9ecee931,
     0x194691f91a73715209ef6512e57672,
     0x29a6,
 ]);
-global K3_3: Secp256k1Fq = BigNum::from_slice([
+global K3_3: Secp256k1Fq = Secp256k1Fq::from_slice([
     0xa12f684bda12f684bda12f38e38d84,
     0x4bda12f684bda12f684bda12f684bd,
     0x2f68,
 ]);
 
-global K4_0: Secp256k1Fq = BigNum::from_slice([
+global K4_0: Secp256k1Fq = Secp256k1Fq::from_slice([
     0xfffffffffffffffffffffefffff93b,
     0xffffffffffffffffffffffffffffff,
     0xffff,
 ]);
-global K4_1: Secp256k1Fq = BigNum::from_slice([
+global K4_1: Secp256k1Fq = Secp256k1Fq::from_slice([
     0x67c1bfc8e8d978dfb425d2685c2573,
     0x534bb8bdb49fd5e9e6632722c29894,
     0x7a06,
 ]);
-global K4_2: Secp256k1Fq = BigNum::from_slice([
+global K4_2: Secp256k1Fq = Secp256k1Fq::from_slice([
     0x3d21162f0d6299a7bf8192bfd2a76f,
     0xaa716545ca2cf3a70c3fa8fe337e0a,
     0x6484,
@@ -112,13 +112,13 @@ fn y_den(x: Secp256k1Fq, x2: Secp256k1Fq, x3: Secp256k1Fq) -> Secp256k1Fq {
 
 #[test]
 fn test_iso_map() {
-    let p: Secp256k1 = BigCurve {
-        x: BigNum::from_slice([
+    let p = Secp256k1 {
+        x: Secp256k1Fq::from_slice([
             0xf7ae5f23c431edeb6be5bb360925ea,
             0xce532d92416a9488104157036455a0,
             0x8dec,
         ]),
-        y: BigNum::from_slice([
+        y: Secp256k1Fq::from_slice([
             0x13d22e4d45e5bef361e486c6a5da4a,
             0xae1c326847bd4a133e5dee6b2ca67c,
             0xe249,
@@ -128,13 +128,13 @@ fn test_iso_map() {
 
     let actual = iso_map(p);
 
-    let expected: Secp256k1 = BigCurve {
-        x: BigNum::from_slice([
+    let expected = Secp256k1 {
+        x: Secp256k1Fq::from_slice([
             0x7c2a947a20fd9ad71039f8b0e29ff8,
             0x6d261a5e00fe5cf45e827b507643e6,
             0xf89d,
         ]),
-        y: BigNum::from_slice([
+        y: Secp256k1Fq::from_slice([
             0x1ce936d563bc1cee1dcffc806caf57,
             0x55e0cc34a9176ead91c6c3acb1aacb,
             0xb338,
diff --git a/crates/plume/src/lib.nr b/crates/plume/src/lib.nr
index 5656e6c..d603258 100644
--- a/crates/plume/src/lib.nr
+++ b/crates/plume/src/lib.nr
@@ -4,13 +4,13 @@ mod expand_message_xmd;
 mod map_to_curve;
 mod iso_map;
 
+use crate::hash_to_curve::hash_to_curve;
 use bignum::BigNum;
+use nodash::array::pack_bytes;
 use noir_bigcurve::BigCurve;
-use noir_bigcurve::curves::secp256k1::{Secp256k1, Secp256k1Fr, Secp256k1Scalar};
+use noir_bigcurve::curves::secp256k1::{Secp256k1, Secp256k1Fr, Secp256k1Fq, Secp256k1Scalar};
 use noir_bigcurve::scalar_field::ScalarField;
-use std::hash::sha256;
-
-use crate::hash_to_curve::hash_to_curve;
+use std::hash::poseidon2::Poseidon2::hash;
 
 comptime global G: Secp256k1 = BigCurve::one();
 comptime global COMPRESSED_SIZE_BYTES: u32 = 33;
@@ -21,11 +21,11 @@ pub fn plume_v1<let N: u32>(
     s: Secp256k1Scalar,
     pk: Secp256k1,
     nullifier: Secp256k1,
-) -> [u8; 32] {
+) -> Field {
     let (r_point, hashed_to_curve_r, hashed_to_curve) =
         check_ec_equations(msg, c, s, pk, nullifier);
 
-    sha256_12_coordinates(pk, hashed_to_curve, nullifier, r_point, hashed_to_curve_r)
+    poseidon_12_coordinates(pk, hashed_to_curve, nullifier, r_point, hashed_to_curve_r)
 }
 
 pub fn plume_v2<let N: u32>(
@@ -86,13 +86,13 @@ fn compress_ec_point(p: Secp256k1) -> [u8; COMPRESSED_SIZE_BYTES] {
     compressed
 }
 
-fn sha256_12_coordinates(
+fn poseidon_12_coordinates(
     pk: Secp256k1,
     h: Secp256k1,
     nullifier: Secp256k1,
     gr: Secp256k1,
     hr: Secp256k1,
-) -> [u8; 32] {
+) -> Field {
     let mut compressed = [[0 as u8; COMPRESSED_SIZE_BYTES]; 6];
     compressed[0] = compress_ec_point(G);
     compressed[1] = compress_ec_point(pk);
@@ -109,12 +109,14 @@ fn sha256_12_coordinates(
         }
     }
 
-    sha256(res)
+    let packed_res = pack_bytes(res);
+
+    hash(packed_res, packed_res.len())
 }
 
 #[test]
 fn test_compress_ec_point() {
-    let sk: Secp256k1Fr = BigNum::from_be_bytes([
+    let sk: Secp256k1Fr = Secp256k1Fr::from_be_bytes([
         141, 102, 7, 178, 108, 210, 195, 217, 224, 140, 81, 3, 56, 193, 15, 69, 117, 230, 143, 45,
         65, 58, 179, 31, 202, 239, 115, 0, 202, 161, 243, 112,
     ]);
@@ -133,19 +135,19 @@ fn test_compress_ec_point() {
 
 #[test]
 fn test_nullifier() {
-    let sk: Secp256k1Fr = BigNum::from_be_bytes([
+    let sk: Secp256k1Fr = Secp256k1Fr::from_be_bytes([
         81, 155, 66, 61, 113, 95, 139, 88, 31, 79, 168, 238, 89, 244, 119, 26, 91, 68, 200, 19, 11,
         78, 62, 172, 202, 84, 165, 109, 218, 114, 180, 100,
     ]);
     let sk: Secp256k1Scalar = ScalarField::from_bignum(sk);
 
-    let H: Secp256k1 = BigCurve {
-        x: BigNum::from_slice([
+    let H = Secp256k1 {
+        x: Secp256k1Fq::from_slice([
             0x2affbc49c54d1136a2190db0800b65,
             0x2d0e12679f23c218889395abcdc01f,
             0xbcac,
         ]),
-        y: BigNum::from_slice([
+        y: Secp256k1Fq::from_slice([
             0xa91a53e32b3752145d87f0cd70966e,
             0xb339c974c0e757d348081f90a123b0,
             0x3bcf,
@@ -155,12 +157,12 @@ fn test_nullifier() {
 
     let actual = H.mul(sk);
 
-    let expected: Secp256k1 = BigCurve {
-        x: BigNum::from_be_bytes([
+    let expected: Secp256k1 = Secp256k1 {
+        x: Secp256k1Fq::from_be_bytes([
             87, 188, 62, 210, 129, 114, 239, 138, 221, 228, 185, 224, 194, 204, 231, 69, 252, 197,
             166, 100, 115, 164, 92, 30, 98, 111, 29, 12, 103, 229, 88, 48,
         ]),
-        y: BigNum::from_be_bytes([
+        y: Secp256k1Fq::from_be_bytes([
             106, 47, 65, 72, 141, 88, 243, 58, 228, 110, 221, 33, 136, 225, 17, 96, 159, 159, 58,
             230, 126, 163, 143, 168, 145, 214, 8, 127, 229, 158, 203, 115,
         ]),
@@ -333,7 +335,7 @@ fn test_sha_256_12_coordinates() {
     let pk = G.mul(sk);
     let nullifier = hashed_to_curve.mul(sk);
 
-    let actual = sha256_12_coordinates(pk, hashed_to_curve, nullifier, r_point, hashed_to_curve_r);
+    let actual = poseidon_12_coordinates(pk, hashed_to_curve, nullifier, r_point, hashed_to_curve_r);
 
     let expected = [
         198, 167, 252, 44, 146, 109, 219, 175, 32, 115, 26, 71, 159, 182, 86, 111, 45, 170, 85, 20, 186, 174, 82, 35, 254, 59, 50, 237, 188, 232, 50, 84
@@ -434,7 +436,7 @@ fn test_plume_v2() {
             res[i*COMPRESSED_SIZE_BYTES + j] = compressed[i][j];
         }
     }
-    let actual = sha256(res);
+    let actual = hash(res);
 
     assert(expected == actual);
 }
diff --git a/crates/plume/src/map_to_curve.nr b/crates/plume/src/map_to_curve.nr
index a1c938a..ef51dee 100644
--- a/crates/plume/src/map_to_curve.nr
+++ b/crates/plume/src/map_to_curve.nr
@@ -11,19 +11,19 @@ use noir_bigcurve::BigCurve;
 use noir_bigcurve::curves::secp256k1::{Secp256k1, Secp256k1_Params, Secp256k1Fq};
 
 // https://www.ietf.org/archive/id/draft-irtf-cfrg-hash-to-curve-13.html#section-8.7
-global Z: Secp256k1Fq = BigNum::from_slice([
+global Z: Secp256k1Fq = Secp256k1Fq::from_slice([
     0xfffffffffffffffffffffefffffc24,
     0xffffffffffffffffffffffffffffff,
     0xffff,
 ]);
-global A: Secp256k1Fq = BigNum::from_slice([
+global A: Secp256k1Fq = Secp256k1Fq::from_slice([
     0x53d363cb6f0e5d405447c01a444533,
     0x31abdd661adca08a5558f0f5d272e9,
     0x3f87,
 ]);
-global B: Secp256k1Fq = BigNum::from_slice([0x6eb, 0, 0]);
+global B: Secp256k1Fq = Secp256k1Fq::from_slice([0x6eb, 0, 0]);
 
-comptime global ONE: Secp256k1Fq = BigNum::one();
+comptime global ONE: Secp256k1Fq = Secp256k1Fq::one();
 
 // Returns point E' isogeneous to secp256k1.
 pub fn map_to_curve(u: Secp256k1Fq) -> Secp256k1 {
@@ -72,7 +72,7 @@ fn select_xy(
 
 #[test]
 fn test_inverse() {
-    let value: Secp256k1Fq = BigNum::from_slice([
+    let value: Secp256k1Fq = Secp256k1Fq::from_slice([
         0x387936733e29cddb43759809208354,
         0xc334daf72303fb27f6aad8201a9465,
         0xc6f1,
@@ -90,33 +90,33 @@ fn test_inverse() {
 
 #[test]
 fn test_select_xy_1() {
-    let x1: Secp256k1Fq = BigNum::from_slice([123, 0, 0]);
-    let x2: Secp256k1Fq = BigNum::from_slice([200, 0, 0]);
-    let gx1: Secp256k1Fq = BigNum::from_slice([4, 0, 0]);
-    let gx2: Secp256k1Fq = BigNum::from_slice([5, 0, 0]);
+    let x1: Secp256k1Fq = Secp256k1Fq::from_slice([123, 0, 0]);
+    let x2: Secp256k1Fq = Secp256k1Fq::from_slice([200, 0, 0]);
+    let gx1: Secp256k1Fq = Secp256k1Fq::from_slice([4, 0, 0]);
+    let gx2: Secp256k1Fq = Secp256k1Fq::from_slice([5, 0, 0]);
 
     let (actual_x, actual_y) = select_xy(x1, x2, gx1, gx2);
 
     assert(actual_x == x1);
-    assert(actual_y == BigNum::from_slice([2, 0, 0]));
+    assert(actual_y == Secp256k1Fq::from_slice([2, 0, 0]));
 }
 
 #[test]
 fn test_select_xy_2() {
-    let x1: Secp256k1Fq = BigNum::from_slice([123, 0, 0]);
-    let x2: Secp256k1Fq = BigNum::from_slice([200, 1, 0]);
-    let gx1: Secp256k1Fq = BigNum::from_slice([5, 0, 0]);
-    let gx2: Secp256k1Fq = BigNum::from_slice([4, 0, 0]);
+    let x1: Secp256k1Fq = Secp256k1Fq::from_slice([123, 0, 0]);
+    let x2: Secp256k1Fq = Secp256k1Fq::from_slice([200, 1, 0]);
+    let gx1: Secp256k1Fq = Secp256k1Fq::from_slice([5, 0, 0]);
+    let gx2: Secp256k1Fq = Secp256k1Fq::from_slice([4, 0, 0]);
 
     let (actual_x, actual_y) = select_xy(x1, x2, gx1, gx2);
 
     assert(actual_x == x2);
-    assert(actual_y == BigNum::from_slice([2, 0, 0]));
+    assert(actual_y == Secp256k1Fq::from_slice([2, 0, 0]));
 }
 
 #[test]
 fn test_map_to_curve() {
-    let u = BigNum::from_slice([
+    let u = Secp256k1Fq::from_slice([
         0x491f544767e18a4873f397b08a2b61,
         0xab5d3679a1f7601e3bdf94ced1f43e,
         0x128a,
diff --git a/crates/use_v1/Nargo.toml b/crates/use_v1/Nargo.toml
index a7db35d..e651247 100644
--- a/crates/use_v1/Nargo.toml
+++ b/crates/use_v1/Nargo.toml
@@ -8,5 +8,6 @@ compiler_version = ">=0.36.0"
 
 [dependencies]
 plume = { path = "../plume" }
-bignum = {tag = "v0.4.1", git = "https://github.com/noir-lang/noir-bignum"}
-noir_bigcurve = {tag = "v0.5.0", git = "https://github.com/noir-lang/noir_bigcurve"}
\ No newline at end of file
+bignum = { tag = "main", git = "https://github.com/noir-lang/noir-bignum" }
+noir_bigcurve = { tag = "main", git = "https://github.com/noir-lang/noir_bigcurve" }
+nodash = { tag = "main", git = "https://github.com/signorecello/nodash" }
diff --git a/crates/use_v1/src/main.nr b/crates/use_v1/src/main.nr
index a86bae3..b65ef2e 100644
--- a/crates/use_v1/src/main.nr
+++ b/crates/use_v1/src/main.nr
@@ -1,6 +1,7 @@
 use bignum::BigNum;
+use nodash::array::pack_bytes;
 use noir_bigcurve::BigCurve;
-use noir_bigcurve::curves::secp256k1::{Secp256k1, Secp256k1Fr, Secp256k1Scalar};
+use noir_bigcurve::curves::secp256k1::{Secp256k1, Secp256k1Fq, Secp256k1Scalar};
 use noir_bigcurve::scalar_field::ScalarField;
 
 use plume::plume_v1;
@@ -25,18 +26,18 @@ pub fn main(
         as_point([nullifier_x, nullifier_y]),
     );
 
-    assert(c == actual_c);
+    assert(pack_bytes(c)[0] == actual_c);
 }
 
 fn as_scalar(bytes: [u8; 32]) -> Secp256k1Scalar {
-    let scalar: Secp256k1Fr = BigNum::from_be_bytes(bytes);
-    ScalarField::from_bignum(scalar)
+    let scalar: Secp256k1Fq = Secp256k1Fq::from_be_bytes(bytes);
+    Secp256k1Scalar::from_bignum(scalar)
 }
 
 fn as_point(bytes: [[u8; 32]; 2]) -> Secp256k1 {
-    BigCurve {
-        x: BigNum::from_be_bytes(bytes[0]),
-        y: BigNum::from_be_bytes(bytes[1]),
+    Secp256k1 {
+        x: Secp256k1Fq::from_be_bytes(bytes[0]),
+        y: Secp256k1Fq::from_be_bytes(bytes[1]),
         is_infinity: false,
     }
 }
diff --git a/crates/use_v2/Nargo.toml b/crates/use_v2/Nargo.toml
index be74e34..ed3e90d 100644
--- a/crates/use_v2/Nargo.toml
+++ b/crates/use_v2/Nargo.toml
@@ -8,5 +8,5 @@ compiler_version = ">=0.36.0"
 
 [dependencies]
 plume = { path = "../plume" }
-bignum = {tag = "v0.4.1", git = "https://github.com/noir-lang/noir-bignum"}
-noir_bigcurve = {tag = "v0.5.0", git = "https://github.com/noir-lang/noir_bigcurve"}
\ No newline at end of file
+bignum = { tag = "main", git = "https://github.com/noir-lang/noir-bignum" }
+noir_bigcurve = { tag = "main", git = "https://github.com/noir-lang/noir_bigcurve" }
diff --git a/crates/use_v2/src/main.nr b/crates/use_v2/src/main.nr
index 540e032..6ab18ab 100644
--- a/crates/use_v2/src/main.nr
+++ b/crates/use_v2/src/main.nr
@@ -1,6 +1,6 @@
 use bignum::BigNum;
 use noir_bigcurve::BigCurve;
-use noir_bigcurve::curves::secp256k1::{Secp256k1, Secp256k1Fr, Secp256k1Scalar};
+use noir_bigcurve::curves::secp256k1::{Secp256k1, Secp256k1Fq, Secp256k1Scalar};
 use noir_bigcurve::scalar_field::ScalarField;
 
 use plume::plume_v2;
@@ -27,14 +27,14 @@ pub fn main(
 }
 
 fn as_scalar(bytes: [u8; 32]) -> Secp256k1Scalar {
-    let scalar: Secp256k1Fr = BigNum::from_be_bytes(bytes);
-    ScalarField::from_bignum(scalar)
+    let scalar: Secp256k1Fq = Secp256k1Fq::from_be_bytes(bytes);
+    Secp256k1Scalar::from_bignum(scalar)
 }
 
 fn as_point(bytes: [[u8; 32]; 2]) -> Secp256k1 {
-    BigCurve {
-        x: BigNum::from_be_bytes(bytes[0]),
-        y: BigNum::from_be_bytes(bytes[1]),
+    Secp256k1 {
+        x: Secp256k1Fq::from_be_bytes(bytes[0]),
+        y: Secp256k1Fq::from_be_bytes(bytes[1]),
         is_infinity: false,
     }
 }
diff --git a/web/src/index.ts b/web/src/index.ts
index bf47f1d..26df7d9 100644
--- a/web/src/index.ts
+++ b/web/src/index.ts
@@ -1,11 +1,11 @@
 import { Noir } from '@noir-lang/noir_js';
 import { CompiledCircuit, InputMap } from '@noir-lang/types';
-import { BarretenbergBackend, UltraHonkBackend } from '@noir-lang/backend_barretenberg';
+import { UltraPlonkBackend, UltraHonkBackend } from '@aztec/bb.js';
 import { parse } from 'toml';
 import initNoirC from '@noir-lang/noirc_abi';
 import initACVM from '@noir-lang/acvm_js';
 
-export async function benchPlume(circuitPath: string, inputsPath: string){
+export async function benchPlume(circuitPath: string, inputsPath: string) {
   const [circuit, inputs] = await Promise.all([
     getCompiledCircuit(circuitPath),
     getInputMap(inputsPath),
@@ -36,7 +36,7 @@ export async function getInputMap(path: string): Promise<InputMap> {
   return parsedData;
 }
 
-export async function benchCircuit(circuit: CompiledCircuit, inputs: InputMap){
+export async function benchCircuit(circuit: CompiledCircuit, inputs: InputMap) {
   console.time('Execution Time');
   const { witness } = await new Noir(circuit).execute(inputs);
   console.timeEnd('Execution Time');
@@ -48,7 +48,7 @@ export async function benchCircuit(circuit: CompiledCircuit, inputs: InputMap){
 }
 
 export async function benchUltraPlonk(circuit: CompiledCircuit, witness: Uint8Array) {
-  const backend = new BarretenbergBackend(circuit);
+  const backend = new UltraPlonkBackend(circuit.bytecode);
 
   console.time('UltraPlonk Proof Generation Time');
   const proof = await backend.generateProof(witness);
@@ -61,8 +61,8 @@ export async function benchUltraPlonk(circuit: CompiledCircuit, witness: Uint8Ar
   console.log('UltraPlonk Verification result:', result);
 }
 
-export async function benchUltraHonk(circuit: CompiledCircuit, witness: Uint8Array){
-  const backend = new UltraHonkBackend(circuit);
+export async function benchUltraHonk(circuit: CompiledCircuit, witness: Uint8Array) {
+  const backend = new UltraHonkBackend(circuit.bytecode);
 
   console.time('UltraHonk Proof Generation Time');
   const proof = await backend.generateProof(witness);
@@ -80,15 +80,17 @@ export async function benchUltraHonk(circuit: CompiledCircuit, witness: Uint8Arr
     console.log('Initializing ACVM and NoirC...');
     await Promise.all([
       initACVM(new URL('@noir-lang/acvm_js/web/acvm_js_bg.wasm', import.meta.url).toString()),
-      initNoirC(new URL('@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm', import.meta.url).toString()),
+      initNoirC(
+        new URL('@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm', import.meta.url).toString(),
+      ),
     ]);
 
     console.log('Starting Benchmarks for V1');
-    await benchPlume("/artifacts/use_v1.json", "/artifacts/use_v1_prover.toml");
+    await benchPlume('/artifacts/use_v1.json', '/artifacts/use_v1_prover.toml');
 
     console.log('Starting Benchmarks for V2');
-    await benchPlume("/artifacts/use_v2.json", "/artifacts/use_v2_prover.toml");
+    await benchPlume('/artifacts/use_v2.json', '/artifacts/use_v2_prover.toml');
   } catch (error) {
     console.error('Error running benchmarks:', error);
   }
-})();
\ No newline at end of file
+})();