chore!: rename bigint_neg into bigint_sub (#4420)

Resolves noir issue: noir-lang/noir#4243

The bigint_neg opcode was implemented with a sub, instead of a negate as
the name suggest. The name has simply been changed to sub.

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,

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);

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,16 +2674,16 @@ 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);
 }
 
 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,16 +3602,16 @@ 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);
 }
 
 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);

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),

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![]