diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp
index a967b01b647..7d48827ef27 100644
--- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp
+++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp
@@ -268,7 +268,7 @@ void handle_blackbox_func_call(Circuit::Opcode::BlackBoxFuncCall const& arg, Aci
                     .result = arg.output,
                     .opcode = BigIntOperationType::Add,
                 });
-            } else if constexpr (std::is_same_v<T, Circuit::BlackBoxFuncCall::BigIntNeg>) {
+            } else if constexpr (std::is_same_v<T, Circuit::BlackBoxFuncCall::BigIntSub>) {
                 af.bigint_operations.push_back(BigIntOperation{
                     .lhs = arg.lhs,
                     .rhs = arg.rhs,
diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
index fc6ad6b3fa7..7de4fe12cbe 100644
--- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
+++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp
@@ -206,14 +206,14 @@ struct BlackBoxFuncCall {
         static BigIntAdd bincodeDeserialize(std::vector<uint8_t>);
     };
 
-    struct BigIntNeg {
+    struct BigIntSub {
         uint32_t lhs;
         uint32_t rhs;
         uint32_t output;
 
-        friend bool operator==(const BigIntNeg&, const BigIntNeg&);
+        friend bool operator==(const BigIntSub&, const BigIntSub&);
         std::vector<uint8_t> bincodeSerialize() const;
-        static BigIntNeg bincodeDeserialize(std::vector<uint8_t>);
+        static BigIntSub bincodeDeserialize(std::vector<uint8_t>);
     };
 
     struct BigIntMul {
@@ -293,7 +293,7 @@ struct BlackBoxFuncCall {
                  Keccakf1600,
                  RecursiveAggregation,
                  BigIntAdd,
-                 BigIntNeg,
+                 BigIntSub,
                  BigIntMul,
                  BigIntDiv,
                  BigIntFromLeBytes,
@@ -637,14 +637,14 @@ struct BlackBoxOp {
         static BigIntAdd bincodeDeserialize(std::vector<uint8_t>);
     };
 
-    struct BigIntNeg {
+    struct BigIntSub {
         Circuit::MemoryAddress lhs;
         Circuit::MemoryAddress rhs;
         Circuit::MemoryAddress output;
 
-        friend bool operator==(const BigIntNeg&, const BigIntNeg&);
+        friend bool operator==(const BigIntSub&, const BigIntSub&);
         std::vector<uint8_t> bincodeSerialize() const;
-        static BigIntNeg bincodeDeserialize(std::vector<uint8_t>);
+        static BigIntSub bincodeDeserialize(std::vector<uint8_t>);
     };
 
     struct BigIntMul {
@@ -719,7 +719,7 @@ struct BlackBoxOp {
                  FixedBaseScalarMul,
                  EmbeddedCurveAdd,
                  BigIntAdd,
-                 BigIntNeg,
+                 BigIntSub,
                  BigIntMul,
                  BigIntDiv,
                  BigIntFromLeBytes,
@@ -3071,7 +3071,7 @@ Circuit::BlackBoxFuncCall::BigIntAdd serde::Deserializable<Circuit::BlackBoxFunc
 
 namespace Circuit {
 
-inline bool operator==(const BlackBoxFuncCall::BigIntNeg& lhs, const BlackBoxFuncCall::BigIntNeg& rhs)
+inline bool operator==(const BlackBoxFuncCall::BigIntSub& lhs, const BlackBoxFuncCall::BigIntSub& rhs)
 {
     if (!(lhs.lhs == rhs.lhs)) {
         return false;
@@ -3085,17 +3085,17 @@ inline bool operator==(const BlackBoxFuncCall::BigIntNeg& lhs, const BlackBoxFun
     return true;
 }
 
-inline std::vector<uint8_t> BlackBoxFuncCall::BigIntNeg::bincodeSerialize() const
+inline std::vector<uint8_t> BlackBoxFuncCall::BigIntSub::bincodeSerialize() const
 {
     auto serializer = serde::BincodeSerializer();
-    serde::Serializable<BlackBoxFuncCall::BigIntNeg>::serialize(*this, serializer);
+    serde::Serializable<BlackBoxFuncCall::BigIntSub>::serialize(*this, serializer);
     return std::move(serializer).bytes();
 }
 
-inline BlackBoxFuncCall::BigIntNeg BlackBoxFuncCall::BigIntNeg::bincodeDeserialize(std::vector<uint8_t> input)
+inline BlackBoxFuncCall::BigIntSub BlackBoxFuncCall::BigIntSub::bincodeDeserialize(std::vector<uint8_t> input)
 {
     auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<BlackBoxFuncCall::BigIntNeg>::deserialize(deserializer);
+    auto value = serde::Deserializable<BlackBoxFuncCall::BigIntSub>::deserialize(deserializer);
     if (deserializer.get_buffer_offset() < input.size()) {
         throw_or_abort("Some input bytes were not read");
     }
@@ -3106,8 +3106,8 @@ inline BlackBoxFuncCall::BigIntNeg BlackBoxFuncCall::BigIntNeg::bincodeDeseriali
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntNeg>::serialize(
-    const Circuit::BlackBoxFuncCall::BigIntNeg& obj, Serializer& serializer)
+void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntSub>::serialize(
+    const Circuit::BlackBoxFuncCall::BigIntSub& obj, Serializer& serializer)
 {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
@@ -3116,10 +3116,10 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntNeg>::serialize(
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::BigIntNeg serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntNeg>::deserialize(
+Circuit::BlackBoxFuncCall::BigIntSub serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntSub>::deserialize(
     Deserializer& deserializer)
 {
-    Circuit::BlackBoxFuncCall::BigIntNeg obj;
+    Circuit::BlackBoxFuncCall::BigIntSub obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
@@ -4273,7 +4273,7 @@ Circuit::BlackBoxOp::BigIntAdd serde::Deserializable<Circuit::BlackBoxOp::BigInt
 
 namespace Circuit {
 
-inline bool operator==(const BlackBoxOp::BigIntNeg& lhs, const BlackBoxOp::BigIntNeg& rhs)
+inline bool operator==(const BlackBoxOp::BigIntSub& lhs, const BlackBoxOp::BigIntSub& rhs)
 {
     if (!(lhs.lhs == rhs.lhs)) {
         return false;
@@ -4287,17 +4287,17 @@ inline bool operator==(const BlackBoxOp::BigIntNeg& lhs, const BlackBoxOp::BigIn
     return true;
 }
 
-inline std::vector<uint8_t> BlackBoxOp::BigIntNeg::bincodeSerialize() const
+inline std::vector<uint8_t> BlackBoxOp::BigIntSub::bincodeSerialize() const
 {
     auto serializer = serde::BincodeSerializer();
-    serde::Serializable<BlackBoxOp::BigIntNeg>::serialize(*this, serializer);
+    serde::Serializable<BlackBoxOp::BigIntSub>::serialize(*this, serializer);
     return std::move(serializer).bytes();
 }
 
-inline BlackBoxOp::BigIntNeg BlackBoxOp::BigIntNeg::bincodeDeserialize(std::vector<uint8_t> input)
+inline BlackBoxOp::BigIntSub BlackBoxOp::BigIntSub::bincodeDeserialize(std::vector<uint8_t> input)
 {
     auto deserializer = serde::BincodeDeserializer(input);
-    auto value = serde::Deserializable<BlackBoxOp::BigIntNeg>::deserialize(deserializer);
+    auto value = serde::Deserializable<BlackBoxOp::BigIntSub>::deserialize(deserializer);
     if (deserializer.get_buffer_offset() < input.size()) {
         throw_or_abort("Some input bytes were not read");
     }
@@ -4308,7 +4308,7 @@ inline BlackBoxOp::BigIntNeg BlackBoxOp::BigIntNeg::bincodeDeserialize(std::vect
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::BigIntNeg>::serialize(const Circuit::BlackBoxOp::BigIntNeg& obj,
+void serde::Serializable<Circuit::BlackBoxOp::BigIntSub>::serialize(const Circuit::BlackBoxOp::BigIntSub& obj,
                                                                     Serializer& serializer)
 {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
@@ -4318,10 +4318,10 @@ void serde::Serializable<Circuit::BlackBoxOp::BigIntNeg>::serialize(const Circui
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::BigIntNeg serde::Deserializable<Circuit::BlackBoxOp::BigIntNeg>::deserialize(
+Circuit::BlackBoxOp::BigIntSub serde::Deserializable<Circuit::BlackBoxOp::BigIntSub>::deserialize(
     Deserializer& deserializer)
 {
-    Circuit::BlackBoxOp::BigIntNeg obj;
+    Circuit::BlackBoxOp::BigIntSub obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
diff --git a/noir/acvm-repo/acir/codegen/acir.cpp b/noir/acvm-repo/acir/codegen/acir.cpp
index c26d6528c4f..73c6054a603 100644
--- a/noir/acvm-repo/acir/codegen/acir.cpp
+++ b/noir/acvm-repo/acir/codegen/acir.cpp
@@ -206,14 +206,14 @@ namespace Circuit {
             static BigIntAdd bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BigIntNeg {
+        struct BigIntSub {
             uint32_t lhs;
             uint32_t rhs;
             uint32_t output;
 
-            friend bool operator==(const BigIntNeg&, const BigIntNeg&);
+            friend bool operator==(const BigIntSub&, const BigIntSub&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BigIntNeg bincodeDeserialize(std::vector<uint8_t>);
+            static BigIntSub bincodeDeserialize(std::vector<uint8_t>);
         };
 
         struct BigIntMul {
@@ -275,7 +275,7 @@ namespace Circuit {
             static Sha256Compression bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<AND, XOR, RANGE, SHA256, Blake2s, Blake3, SchnorrVerify, PedersenCommitment, PedersenHash, EcdsaSecp256k1, EcdsaSecp256r1, FixedBaseScalarMul, EmbeddedCurveAdd, Keccak256, Keccak256VariableLength, Keccakf1600, RecursiveAggregation, BigIntAdd, BigIntNeg, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
+        std::variant<AND, XOR, RANGE, SHA256, Blake2s, Blake3, SchnorrVerify, PedersenCommitment, PedersenHash, EcdsaSecp256k1, EcdsaSecp256r1, FixedBaseScalarMul, EmbeddedCurveAdd, Keccak256, Keccak256VariableLength, Keccakf1600, RecursiveAggregation, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
 
         friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -612,14 +612,14 @@ namespace Circuit {
             static BigIntAdd bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct BigIntNeg {
+        struct BigIntSub {
             Circuit::MemoryAddress lhs;
             Circuit::MemoryAddress rhs;
             Circuit::MemoryAddress output;
 
-            friend bool operator==(const BigIntNeg&, const BigIntNeg&);
+            friend bool operator==(const BigIntSub&, const BigIntSub&);
             std::vector<uint8_t> bincodeSerialize() const;
-            static BigIntNeg bincodeDeserialize(std::vector<uint8_t>);
+            static BigIntSub bincodeDeserialize(std::vector<uint8_t>);
         };
 
         struct BigIntMul {
@@ -681,7 +681,7 @@ namespace Circuit {
             static Sha256Compression bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<Sha256, Blake2s, Blake3, Keccak256, Keccakf1600, EcdsaSecp256k1, EcdsaSecp256r1, SchnorrVerify, PedersenCommitment, PedersenHash, FixedBaseScalarMul, EmbeddedCurveAdd, BigIntAdd, BigIntNeg, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
+        std::variant<Sha256, Blake2s, Blake3, Keccak256, Keccakf1600, EcdsaSecp256k1, EcdsaSecp256r1, SchnorrVerify, PedersenCommitment, PedersenHash, FixedBaseScalarMul, EmbeddedCurveAdd, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
 
         friend bool operator==(const BlackBoxOp&, const BlackBoxOp&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -2648,22 +2648,22 @@ Circuit::BlackBoxFuncCall::BigIntAdd serde::Deserializable<Circuit::BlackBoxFunc
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxFuncCall::BigIntNeg &lhs, const BlackBoxFuncCall::BigIntNeg &rhs) {
+    inline bool operator==(const BlackBoxFuncCall::BigIntSub &lhs, const BlackBoxFuncCall::BigIntSub &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
         if (!(lhs.rhs == rhs.rhs)) { return false; }
         if (!(lhs.output == rhs.output)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxFuncCall::BigIntNeg::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxFuncCall::BigIntSub::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxFuncCall::BigIntNeg>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxFuncCall::BigIntSub>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxFuncCall::BigIntNeg BlackBoxFuncCall::BigIntNeg::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxFuncCall::BigIntSub BlackBoxFuncCall::BigIntSub::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxFuncCall::BigIntNeg>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxFuncCall::BigIntSub>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -2674,7 +2674,7 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntNeg>::serialize(const Circuit::BlackBoxFuncCall::BigIntNeg &obj, Serializer &serializer) {
+void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntSub>::serialize(const Circuit::BlackBoxFuncCall::BigIntSub &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2682,8 +2682,8 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntNeg>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::BigIntNeg serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntNeg>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::BigIntNeg obj;
+Circuit::BlackBoxFuncCall::BigIntSub serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntSub>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxFuncCall::BigIntSub obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
@@ -3576,22 +3576,22 @@ Circuit::BlackBoxOp::BigIntAdd serde::Deserializable<Circuit::BlackBoxOp::BigInt
 
 namespace Circuit {
 
-    inline bool operator==(const BlackBoxOp::BigIntNeg &lhs, const BlackBoxOp::BigIntNeg &rhs) {
+    inline bool operator==(const BlackBoxOp::BigIntSub &lhs, const BlackBoxOp::BigIntSub &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
         if (!(lhs.rhs == rhs.rhs)) { return false; }
         if (!(lhs.output == rhs.output)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::BigIntNeg::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxOp::BigIntSub::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::BigIntNeg>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxOp::BigIntSub>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::BigIntNeg BlackBoxOp::BigIntNeg::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxOp::BigIntSub BlackBoxOp::BigIntSub::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::BigIntNeg>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxOp::BigIntSub>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -3602,7 +3602,7 @@ namespace Circuit {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::BigIntNeg>::serialize(const Circuit::BlackBoxOp::BigIntNeg &obj, Serializer &serializer) {
+void serde::Serializable<Circuit::BlackBoxOp::BigIntSub>::serialize(const Circuit::BlackBoxOp::BigIntSub &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3610,8 +3610,8 @@ void serde::Serializable<Circuit::BlackBoxOp::BigIntNeg>::serialize(const Circui
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::BigIntNeg serde::Deserializable<Circuit::BlackBoxOp::BigIntNeg>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::BigIntNeg obj;
+Circuit::BlackBoxOp::BigIntSub serde::Deserializable<Circuit::BlackBoxOp::BigIntSub>::deserialize(Deserializer &deserializer) {
+    Circuit::BlackBoxOp::BigIntSub obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
diff --git a/noir/acvm-repo/acir/src/circuit/black_box_functions.rs b/noir/acvm-repo/acir/src/circuit/black_box_functions.rs
index 97b4759d350..59a76b46a12 100644
--- a/noir/acvm-repo/acir/src/circuit/black_box_functions.rs
+++ b/noir/acvm-repo/acir/src/circuit/black_box_functions.rs
@@ -50,7 +50,7 @@ pub enum BlackBoxFunc {
     /// BigInt addition
     BigIntAdd,
     /// BigInt subtraction
-    BigIntNeg,
+    BigIntSub,
     /// BigInt multiplication
     BigIntMul,
     /// BigInt division
@@ -91,7 +91,7 @@ impl BlackBoxFunc {
             BlackBoxFunc::RecursiveAggregation => "recursive_aggregation",
             BlackBoxFunc::EcdsaSecp256r1 => "ecdsa_secp256r1",
             BlackBoxFunc::BigIntAdd => "bigint_add",
-            BlackBoxFunc::BigIntNeg => "bigint_neg",
+            BlackBoxFunc::BigIntSub => "bigint_neg",
             BlackBoxFunc::BigIntMul => "bigint_mul",
             BlackBoxFunc::BigIntDiv => "bigint_div",
             BlackBoxFunc::BigIntFromLeBytes => "bigint_from_le_bytes",
@@ -120,7 +120,7 @@ impl BlackBoxFunc {
             "keccakf1600" => Some(BlackBoxFunc::Keccakf1600),
             "recursive_aggregation" => Some(BlackBoxFunc::RecursiveAggregation),
             "bigint_add" => Some(BlackBoxFunc::BigIntAdd),
-            "bigint_neg" => Some(BlackBoxFunc::BigIntNeg),
+            "bigint_sub" => Some(BlackBoxFunc::BigIntSub),
             "bigint_mul" => Some(BlackBoxFunc::BigIntMul),
             "bigint_div" => Some(BlackBoxFunc::BigIntDiv),
             "bigint_from_le_bytes" => Some(BlackBoxFunc::BigIntFromLeBytes),
diff --git a/noir/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs b/noir/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
index ba4964c8912..f73417a4b5b 100644
--- a/noir/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
+++ b/noir/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
@@ -120,7 +120,7 @@ pub enum BlackBoxFuncCall {
         rhs: u32,
         output: u32,
     },
-    BigIntNeg {
+    BigIntSub {
         lhs: u32,
         rhs: u32,
         output: u32,
@@ -193,7 +193,7 @@ impl BlackBoxFuncCall {
             BlackBoxFuncCall::Keccakf1600 { .. } => BlackBoxFunc::Keccakf1600,
             BlackBoxFuncCall::RecursiveAggregation { .. } => BlackBoxFunc::RecursiveAggregation,
             BlackBoxFuncCall::BigIntAdd { .. } => BlackBoxFunc::BigIntAdd,
-            BlackBoxFuncCall::BigIntNeg { .. } => BlackBoxFunc::BigIntNeg,
+            BlackBoxFuncCall::BigIntSub { .. } => BlackBoxFunc::BigIntSub,
             BlackBoxFuncCall::BigIntMul { .. } => BlackBoxFunc::BigIntMul,
             BlackBoxFuncCall::BigIntDiv { .. } => BlackBoxFunc::BigIntDiv,
             BlackBoxFuncCall::BigIntFromLeBytes { .. } => BlackBoxFunc::BigIntFromLeBytes,
@@ -223,7 +223,7 @@ impl BlackBoxFuncCall {
                 vec![*lhs, *rhs]
             }
             BlackBoxFuncCall::BigIntAdd { .. }
-            | BlackBoxFuncCall::BigIntNeg { .. }
+            | BlackBoxFuncCall::BigIntSub { .. }
             | BlackBoxFuncCall::BigIntMul { .. }
             | BlackBoxFuncCall::BigIntDiv { .. }
             | BlackBoxFuncCall::BigIntToLeBytes { .. } => Vec::new(),
@@ -328,7 +328,7 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::RecursiveAggregation { .. }
             | BlackBoxFuncCall::BigIntFromLeBytes { .. }
             | BlackBoxFuncCall::BigIntAdd { .. }
-            | BlackBoxFuncCall::BigIntNeg { .. }
+            | BlackBoxFuncCall::BigIntSub { .. }
             | BlackBoxFuncCall::BigIntMul { .. }
             | BlackBoxFuncCall::BigIntDiv { .. } => {
                 vec![]
diff --git a/noir/acvm-repo/acvm/src/pwg/blackbox/bigint.rs b/noir/acvm-repo/acvm/src/pwg/blackbox/bigint.rs
index 6736c7521cd..986afaa3ce7 100644
--- a/noir/acvm-repo/acvm/src/pwg/blackbox/bigint.rs
+++ b/noir/acvm-repo/acvm/src/pwg/blackbox/bigint.rs
@@ -96,7 +96,7 @@ impl BigIntSolver {
         let rhs = self.get_bigint(rhs, func)?;
         let mut result = match func {
             BlackBoxFunc::BigIntAdd => lhs + rhs,
-            BlackBoxFunc::BigIntNeg => {
+            BlackBoxFunc::BigIntSub => {
                 if lhs >= rhs {
                     &lhs - &rhs
                 } else {
diff --git a/noir/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/noir/acvm-repo/acvm/src/pwg/blackbox/mod.rs
index bf825caf2ff..7146dff87e0 100644
--- a/noir/acvm-repo/acvm/src/pwg/blackbox/mod.rs
+++ b/noir/acvm-repo/acvm/src/pwg/blackbox/mod.rs
@@ -193,7 +193,7 @@ pub(crate) fn solve(
         // Recursive aggregation will be entirely handled by the backend and is not solved by the ACVM
         BlackBoxFuncCall::RecursiveAggregation { .. } => Ok(()),
         BlackBoxFuncCall::BigIntAdd { lhs, rhs, output }
-        | BlackBoxFuncCall::BigIntNeg { lhs, rhs, output }
+        | BlackBoxFuncCall::BigIntSub { lhs, rhs, output }
         | BlackBoxFuncCall::BigIntMul { lhs, rhs, output }
         | BlackBoxFuncCall::BigIntDiv { lhs, rhs, output } => {
             bigint_solver.bigint_op(*lhs, *rhs, *output, bb_func.get_black_box_func())
diff --git a/noir/acvm-repo/brillig/src/black_box.rs b/noir/acvm-repo/brillig/src/black_box.rs
index 9195d8aa6f3..29861d0fd84 100644
--- a/noir/acvm-repo/brillig/src/black_box.rs
+++ b/noir/acvm-repo/brillig/src/black_box.rs
@@ -85,7 +85,7 @@ pub enum BlackBoxOp {
         rhs: MemoryAddress,
         output: MemoryAddress,
     },
-    BigIntNeg {
+    BigIntSub {
         lhs: MemoryAddress,
         rhs: MemoryAddress,
         output: MemoryAddress,
diff --git a/noir/acvm-repo/brillig_vm/src/black_box.rs b/noir/acvm-repo/brillig_vm/src/black_box.rs
index de20d194dde..04aa2bcf9af 100644
--- a/noir/acvm-repo/brillig_vm/src/black_box.rs
+++ b/noir/acvm-repo/brillig_vm/src/black_box.rs
@@ -179,7 +179,7 @@ pub(crate) fn evaluate_black_box<Solver: BlackBoxFunctionSolver>(
             Ok(())
         }
         BlackBoxOp::BigIntAdd { .. } => todo!(),
-        BlackBoxOp::BigIntNeg { .. } => todo!(),
+        BlackBoxOp::BigIntSub { .. } => todo!(),
         BlackBoxOp::BigIntMul { .. } => todo!(),
         BlackBoxOp::BigIntDiv { .. } => todo!(),
         BlackBoxOp::BigIntFromLeBytes { .. } => todo!(),
@@ -204,7 +204,7 @@ fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
         BlackBoxOp::FixedBaseScalarMul { .. } => BlackBoxFunc::FixedBaseScalarMul,
         BlackBoxOp::EmbeddedCurveAdd { .. } => BlackBoxFunc::EmbeddedCurveAdd,
         BlackBoxOp::BigIntAdd { .. } => BlackBoxFunc::BigIntAdd,
-        BlackBoxOp::BigIntNeg { .. } => BlackBoxFunc::BigIntNeg,
+        BlackBoxOp::BigIntSub { .. } => BlackBoxFunc::BigIntSub,
         BlackBoxOp::BigIntMul { .. } => BlackBoxFunc::BigIntMul,
         BlackBoxOp::BigIntDiv { .. } => BlackBoxFunc::BigIntDiv,
         BlackBoxOp::BigIntFromLeBytes { .. } => BlackBoxFunc::BigIntFromLeBytes,
diff --git a/noir/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/noir/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
index 96d80cb8131..dfe23b45034 100644
--- a/noir/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
+++ b/noir/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
@@ -244,13 +244,13 @@ pub(crate) fn convert_black_box_call(
                 )
             }
         }
-        BlackBoxFunc::BigIntNeg => {
+        BlackBoxFunc::BigIntSub => {
             if let (
                 [BrilligVariable::Simple(lhs), BrilligVariable::Simple(rhs)],
                 [BrilligVariable::Simple(output)],
             ) = (function_arguments, function_results)
             {
-                brillig_context.black_box_op_instruction(BlackBoxOp::BigIntNeg {
+                brillig_context.black_box_op_instruction(BlackBoxOp::BigIntSub {
                     lhs: *lhs,
                     rhs: *rhs,
                     output: *output,
diff --git a/noir/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/noir/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index 28359f8dcea..45b6d3d79b2 100644
--- a/noir/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/noir/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -457,7 +457,7 @@ impl DebugShow {
                     output
                 );
             }
-            BlackBoxOp::BigIntNeg { lhs, rhs, output } => {
+            BlackBoxOp::BigIntSub { lhs, rhs, output } => {
                 debug_println!(
                     self.enable_debug_trace,
                     "  BIGINT_NEG {} {} -> {}",
diff --git a/noir/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/noir/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 1656955e416..19f5b208802 100644
--- a/noir/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/noir/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -1199,7 +1199,7 @@ impl AcirContext {
                 (vec![state_len], Vec::new())
             }
             BlackBoxFunc::BigIntAdd
-            | BlackBoxFunc::BigIntNeg
+            | BlackBoxFunc::BigIntSub
             | BlackBoxFunc::BigIntMul
             | BlackBoxFunc::BigIntDiv => {
                 assert_eq!(inputs.len(), 4, "ICE - bigint operation requires 4 inputs");
diff --git a/noir/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/noir/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
index b86fc4eeb5f..4d88a449e1c 100644
--- a/noir/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/noir/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
@@ -252,7 +252,7 @@ impl GeneratedAcir {
                 rhs: constant_inputs[1].to_u128() as u32,
                 output: constant_outputs[0].to_u128() as u32,
             },
-            BlackBoxFunc::BigIntNeg => BlackBoxFuncCall::BigIntNeg {
+            BlackBoxFunc::BigIntSub => BlackBoxFuncCall::BigIntSub {
                 lhs: constant_inputs[0].to_u128() as u32,
                 rhs: constant_inputs[1].to_u128() as u32,
                 output: constant_outputs[0].to_u128() as u32,
@@ -646,7 +646,7 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option<usize> {
 
         // Big integer operations take in 0 inputs. They use constants for their inputs.
         BlackBoxFunc::BigIntAdd
-        | BlackBoxFunc::BigIntNeg
+        | BlackBoxFunc::BigIntSub
         | BlackBoxFunc::BigIntMul
         | BlackBoxFunc::BigIntDiv
         | BlackBoxFunc::BigIntToLeBytes => Some(0),
@@ -696,7 +696,7 @@ fn black_box_expected_output_size(name: BlackBoxFunc) -> Option<usize> {
 
         // Big integer operations return a big integer
         BlackBoxFunc::BigIntAdd
-        | BlackBoxFunc::BigIntNeg
+        | BlackBoxFunc::BigIntSub
         | BlackBoxFunc::BigIntMul
         | BlackBoxFunc::BigIntDiv
         | BlackBoxFunc::BigIntFromLeBytes => Some(0),
diff --git a/noir/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/noir/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index 0178ae9dba1..64f81e05f77 100644
--- a/noir/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/noir/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -434,7 +434,7 @@ fn simplify_black_box_func(
             SimplifyResult::None
         }
         BlackBoxFunc::BigIntAdd
-        | BlackBoxFunc::BigIntNeg
+        | BlackBoxFunc::BigIntSub
         | BlackBoxFunc::BigIntMul
         | BlackBoxFunc::BigIntDiv
         | BlackBoxFunc::RecursiveAggregation
diff --git a/noir/noir_stdlib/src/bigint.nr b/noir/noir_stdlib/src/bigint.nr
index 6414b24d625..11026651207 100644
--- a/noir/noir_stdlib/src/bigint.nr
+++ b/noir/noir_stdlib/src/bigint.nr
@@ -24,8 +24,8 @@ impl BigInt {
     #[builtin(bigint_add)]
     fn bigint_add(self, other: BigInt) -> BigInt {
     }
-    #[builtin(bigint_neg)]
-    fn bigint_neg(self, other: BigInt) -> BigInt {
+    #[builtin(bigint_sub)]
+    fn bigint_sub(self, other: BigInt) -> BigInt {
     }
     #[builtin(bigint_mul)]
     fn bigint_mul(self, other: BigInt) -> BigInt {
@@ -59,7 +59,7 @@ impl Add for BigInt {
 }
 impl Sub for BigInt { 
     fn sub(self: Self, other: BigInt) -> BigInt {
-        self.bigint_neg(other)
+        self.bigint_sub(other)
     }
 }
 impl Mul for BigInt { 
@@ -75,7 +75,7 @@ impl Div for BigInt {
 impl Rem for BigInt { 
     fn rem(self: Self, other: BigInt) -> BigInt {
         let quotient = self.bigint_div(other);
-        self.bigint_neg(quotient.bigint_mul(other))
+        self.bigint_sub(quotient.bigint_mul(other))
     }
 }