Skip to content

Commit c3be58b

Browse files
sirasistantkevaundray
authored and
guipublic
committed
feat!: expose pedersen hash in acir and bb solver (#3269)
Co-authored-by: kevaundray <kevtheappdev@gmail.com>
1 parent ea88441 commit c3be58b

209 files changed

Lines changed: 530 additions & 84 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎acvm-repo/acir/codegen/acir.cpp‎

Lines changed: 132 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -82,14 +82,24 @@ namespace Circuit {
8282
static SchnorrVerify bincodeDeserialize(std::vector<uint8_t>);
8383
};
8484

85-
struct Pedersen {
85+
struct PedersenCommitment {
8686
std::vector<Circuit::FunctionInput> inputs;
8787
uint32_t domain_separator;
8888
std::array<Circuit::Witness, 2> outputs;
8989

90-
friend bool operator==(const Pedersen&, const Pedersen&);
90+
friend bool operator==(const PedersenCommitment&, const PedersenCommitment&);
9191
std::vector<uint8_t> bincodeSerialize() const;
92-
static Pedersen bincodeDeserialize(std::vector<uint8_t>);
92+
static PedersenCommitment bincodeDeserialize(std::vector<uint8_t>);
93+
};
94+
95+
struct PedersenHash {
96+
std::vector<Circuit::FunctionInput> inputs;
97+
uint32_t domain_separator;
98+
Circuit::Witness output;
99+
100+
friend bool operator==(const PedersenHash&, const PedersenHash&);
101+
std::vector<uint8_t> bincodeSerialize() const;
102+
static PedersenHash bincodeDeserialize(std::vector<uint8_t>);
93103
};
94104

95105
struct HashToField128Security {
@@ -167,7 +177,7 @@ namespace Circuit {
167177
static RecursiveAggregation bincodeDeserialize(std::vector<uint8_t>);
168178
};
169179

170-
std::variant<AND, XOR, RANGE, SHA256, Blake2s, SchnorrVerify, Pedersen, HashToField128Security, EcdsaSecp256k1, EcdsaSecp256r1, FixedBaseScalarMul, Keccak256, Keccak256VariableLength, RecursiveAggregation> value;
180+
std::variant<AND, XOR, RANGE, SHA256, Blake2s, SchnorrVerify, PedersenCommitment, PedersenHash, HashToField128Security, EcdsaSecp256k1, EcdsaSecp256r1, FixedBaseScalarMul, Keccak256, Keccak256VariableLength, RecursiveAggregation> value;
171181

172182
friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&);
173183
std::vector<uint8_t> bincodeSerialize() const;
@@ -443,14 +453,24 @@ namespace Circuit {
443453
static SchnorrVerify bincodeDeserialize(std::vector<uint8_t>);
444454
};
445455

446-
struct Pedersen {
456+
struct PedersenCommitment {
447457
Circuit::HeapVector inputs;
448458
Circuit::RegisterIndex domain_separator;
449459
Circuit::HeapArray output;
450460

451-
friend bool operator==(const Pedersen&, const Pedersen&);
461+
friend bool operator==(const PedersenCommitment&, const PedersenCommitment&);
462+
std::vector<uint8_t> bincodeSerialize() const;
463+
static PedersenCommitment bincodeDeserialize(std::vector<uint8_t>);
464+
};
465+
466+
struct PedersenHash {
467+
Circuit::HeapVector inputs;
468+
Circuit::RegisterIndex domain_separator;
469+
Circuit::RegisterIndex output;
470+
471+
friend bool operator==(const PedersenHash&, const PedersenHash&);
452472
std::vector<uint8_t> bincodeSerialize() const;
453-
static Pedersen bincodeDeserialize(std::vector<uint8_t>);
473+
static PedersenHash bincodeDeserialize(std::vector<uint8_t>);
454474
};
455475

456476
struct FixedBaseScalarMul {
@@ -463,7 +483,7 @@ namespace Circuit {
463483
static FixedBaseScalarMul bincodeDeserialize(std::vector<uint8_t>);
464484
};
465485

466-
std::variant<Sha256, Blake2s, Keccak256, HashToField128Security, EcdsaSecp256k1, EcdsaSecp256r1, SchnorrVerify, Pedersen, FixedBaseScalarMul> value;
486+
std::variant<Sha256, Blake2s, Keccak256, HashToField128Security, EcdsaSecp256k1, EcdsaSecp256r1, SchnorrVerify, PedersenCommitment, PedersenHash, FixedBaseScalarMul> value;
467487

468488
friend bool operator==(const BlackBoxOp&, const BlackBoxOp&);
469489
std::vector<uint8_t> bincodeSerialize() const;
@@ -1871,22 +1891,22 @@ Circuit::BlackBoxFuncCall::SchnorrVerify serde::Deserializable<Circuit::BlackBox
18711891

18721892
namespace Circuit {
18731893

1874-
inline bool operator==(const BlackBoxFuncCall::Pedersen &lhs, const BlackBoxFuncCall::Pedersen &rhs) {
1894+
inline bool operator==(const BlackBoxFuncCall::PedersenCommitment &lhs, const BlackBoxFuncCall::PedersenCommitment &rhs) {
18751895
if (!(lhs.inputs == rhs.inputs)) { return false; }
18761896
if (!(lhs.domain_separator == rhs.domain_separator)) { return false; }
18771897
if (!(lhs.outputs == rhs.outputs)) { return false; }
18781898
return true;
18791899
}
18801900

1881-
inline std::vector<uint8_t> BlackBoxFuncCall::Pedersen::bincodeSerialize() const {
1901+
inline std::vector<uint8_t> BlackBoxFuncCall::PedersenCommitment::bincodeSerialize() const {
18821902
auto serializer = serde::BincodeSerializer();
1883-
serde::Serializable<BlackBoxFuncCall::Pedersen>::serialize(*this, serializer);
1903+
serde::Serializable<BlackBoxFuncCall::PedersenCommitment>::serialize(*this, serializer);
18841904
return std::move(serializer).bytes();
18851905
}
18861906

1887-
inline BlackBoxFuncCall::Pedersen BlackBoxFuncCall::Pedersen::bincodeDeserialize(std::vector<uint8_t> input) {
1907+
inline BlackBoxFuncCall::PedersenCommitment BlackBoxFuncCall::PedersenCommitment::bincodeDeserialize(std::vector<uint8_t> input) {
18881908
auto deserializer = serde::BincodeDeserializer(input);
1889-
auto value = serde::Deserializable<BlackBoxFuncCall::Pedersen>::deserialize(deserializer);
1909+
auto value = serde::Deserializable<BlackBoxFuncCall::PedersenCommitment>::deserialize(deserializer);
18901910
if (deserializer.get_buffer_offset() < input.size()) {
18911911
throw serde::deserialization_error("Some input bytes were not read");
18921912
}
@@ -1897,22 +1917,66 @@ namespace Circuit {
18971917

18981918
template <>
18991919
template <typename Serializer>
1900-
void serde::Serializable<Circuit::BlackBoxFuncCall::Pedersen>::serialize(const Circuit::BlackBoxFuncCall::Pedersen &obj, Serializer &serializer) {
1920+
void serde::Serializable<Circuit::BlackBoxFuncCall::PedersenCommitment>::serialize(const Circuit::BlackBoxFuncCall::PedersenCommitment &obj, Serializer &serializer) {
19011921
serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
19021922
serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
19031923
serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
19041924
}
19051925

19061926
template <>
19071927
template <typename Deserializer>
1908-
Circuit::BlackBoxFuncCall::Pedersen serde::Deserializable<Circuit::BlackBoxFuncCall::Pedersen>::deserialize(Deserializer &deserializer) {
1909-
Circuit::BlackBoxFuncCall::Pedersen obj;
1928+
Circuit::BlackBoxFuncCall::PedersenCommitment serde::Deserializable<Circuit::BlackBoxFuncCall::PedersenCommitment>::deserialize(Deserializer &deserializer) {
1929+
Circuit::BlackBoxFuncCall::PedersenCommitment obj;
19101930
obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
19111931
obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
19121932
obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
19131933
return obj;
19141934
}
19151935

1936+
namespace Circuit {
1937+
1938+
inline bool operator==(const BlackBoxFuncCall::PedersenHash &lhs, const BlackBoxFuncCall::PedersenHash &rhs) {
1939+
if (!(lhs.inputs == rhs.inputs)) { return false; }
1940+
if (!(lhs.domain_separator == rhs.domain_separator)) { return false; }
1941+
if (!(lhs.output == rhs.output)) { return false; }
1942+
return true;
1943+
}
1944+
1945+
inline std::vector<uint8_t> BlackBoxFuncCall::PedersenHash::bincodeSerialize() const {
1946+
auto serializer = serde::BincodeSerializer();
1947+
serde::Serializable<BlackBoxFuncCall::PedersenHash>::serialize(*this, serializer);
1948+
return std::move(serializer).bytes();
1949+
}
1950+
1951+
inline BlackBoxFuncCall::PedersenHash BlackBoxFuncCall::PedersenHash::bincodeDeserialize(std::vector<uint8_t> input) {
1952+
auto deserializer = serde::BincodeDeserializer(input);
1953+
auto value = serde::Deserializable<BlackBoxFuncCall::PedersenHash>::deserialize(deserializer);
1954+
if (deserializer.get_buffer_offset() < input.size()) {
1955+
throw serde::deserialization_error("Some input bytes were not read");
1956+
}
1957+
return value;
1958+
}
1959+
1960+
} // end of namespace Circuit
1961+
1962+
template <>
1963+
template <typename Serializer>
1964+
void serde::Serializable<Circuit::BlackBoxFuncCall::PedersenHash>::serialize(const Circuit::BlackBoxFuncCall::PedersenHash &obj, Serializer &serializer) {
1965+
serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
1966+
serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
1967+
serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
1968+
}
1969+
1970+
template <>
1971+
template <typename Deserializer>
1972+
Circuit::BlackBoxFuncCall::PedersenHash serde::Deserializable<Circuit::BlackBoxFuncCall::PedersenHash>::deserialize(Deserializer &deserializer) {
1973+
Circuit::BlackBoxFuncCall::PedersenHash obj;
1974+
obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
1975+
obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
1976+
obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
1977+
return obj;
1978+
}
1979+
19161980
namespace Circuit {
19171981

19181982
inline bool operator==(const BlackBoxFuncCall::HashToField128Security &lhs, const BlackBoxFuncCall::HashToField128Security &rhs) {
@@ -2594,22 +2658,66 @@ Circuit::BlackBoxOp::SchnorrVerify serde::Deserializable<Circuit::BlackBoxOp::Sc
25942658

25952659
namespace Circuit {
25962660

2597-
inline bool operator==(const BlackBoxOp::Pedersen &lhs, const BlackBoxOp::Pedersen &rhs) {
2661+
inline bool operator==(const BlackBoxOp::PedersenCommitment &lhs, const BlackBoxOp::PedersenCommitment &rhs) {
2662+
if (!(lhs.inputs == rhs.inputs)) { return false; }
2663+
if (!(lhs.domain_separator == rhs.domain_separator)) { return false; }
2664+
if (!(lhs.output == rhs.output)) { return false; }
2665+
return true;
2666+
}
2667+
2668+
inline std::vector<uint8_t> BlackBoxOp::PedersenCommitment::bincodeSerialize() const {
2669+
auto serializer = serde::BincodeSerializer();
2670+
serde::Serializable<BlackBoxOp::PedersenCommitment>::serialize(*this, serializer);
2671+
return std::move(serializer).bytes();
2672+
}
2673+
2674+
inline BlackBoxOp::PedersenCommitment BlackBoxOp::PedersenCommitment::bincodeDeserialize(std::vector<uint8_t> input) {
2675+
auto deserializer = serde::BincodeDeserializer(input);
2676+
auto value = serde::Deserializable<BlackBoxOp::PedersenCommitment>::deserialize(deserializer);
2677+
if (deserializer.get_buffer_offset() < input.size()) {
2678+
throw serde::deserialization_error("Some input bytes were not read");
2679+
}
2680+
return value;
2681+
}
2682+
2683+
} // end of namespace Circuit
2684+
2685+
template <>
2686+
template <typename Serializer>
2687+
void serde::Serializable<Circuit::BlackBoxOp::PedersenCommitment>::serialize(const Circuit::BlackBoxOp::PedersenCommitment &obj, Serializer &serializer) {
2688+
serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
2689+
serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
2690+
serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
2691+
}
2692+
2693+
template <>
2694+
template <typename Deserializer>
2695+
Circuit::BlackBoxOp::PedersenCommitment serde::Deserializable<Circuit::BlackBoxOp::PedersenCommitment>::deserialize(Deserializer &deserializer) {
2696+
Circuit::BlackBoxOp::PedersenCommitment obj;
2697+
obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
2698+
obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
2699+
obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
2700+
return obj;
2701+
}
2702+
2703+
namespace Circuit {
2704+
2705+
inline bool operator==(const BlackBoxOp::PedersenHash &lhs, const BlackBoxOp::PedersenHash &rhs) {
25982706
if (!(lhs.inputs == rhs.inputs)) { return false; }
25992707
if (!(lhs.domain_separator == rhs.domain_separator)) { return false; }
26002708
if (!(lhs.output == rhs.output)) { return false; }
26012709
return true;
26022710
}
26032711

2604-
inline std::vector<uint8_t> BlackBoxOp::Pedersen::bincodeSerialize() const {
2712+
inline std::vector<uint8_t> BlackBoxOp::PedersenHash::bincodeSerialize() const {
26052713
auto serializer = serde::BincodeSerializer();
2606-
serde::Serializable<BlackBoxOp::Pedersen>::serialize(*this, serializer);
2714+
serde::Serializable<BlackBoxOp::PedersenHash>::serialize(*this, serializer);
26072715
return std::move(serializer).bytes();
26082716
}
26092717

2610-
inline BlackBoxOp::Pedersen BlackBoxOp::Pedersen::bincodeDeserialize(std::vector<uint8_t> input) {
2718+
inline BlackBoxOp::PedersenHash BlackBoxOp::PedersenHash::bincodeDeserialize(std::vector<uint8_t> input) {
26112719
auto deserializer = serde::BincodeDeserializer(input);
2612-
auto value = serde::Deserializable<BlackBoxOp::Pedersen>::deserialize(deserializer);
2720+
auto value = serde::Deserializable<BlackBoxOp::PedersenHash>::deserialize(deserializer);
26132721
if (deserializer.get_buffer_offset() < input.size()) {
26142722
throw serde::deserialization_error("Some input bytes were not read");
26152723
}
@@ -2620,16 +2728,16 @@ namespace Circuit {
26202728

26212729
template <>
26222730
template <typename Serializer>
2623-
void serde::Serializable<Circuit::BlackBoxOp::Pedersen>::serialize(const Circuit::BlackBoxOp::Pedersen &obj, Serializer &serializer) {
2731+
void serde::Serializable<Circuit::BlackBoxOp::PedersenHash>::serialize(const Circuit::BlackBoxOp::PedersenHash &obj, Serializer &serializer) {
26242732
serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
26252733
serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
26262734
serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
26272735
}
26282736

26292737
template <>
26302738
template <typename Deserializer>
2631-
Circuit::BlackBoxOp::Pedersen serde::Deserializable<Circuit::BlackBoxOp::Pedersen>::deserialize(Deserializer &deserializer) {
2632-
Circuit::BlackBoxOp::Pedersen obj;
2739+
Circuit::BlackBoxOp::PedersenHash serde::Deserializable<Circuit::BlackBoxOp::PedersenHash>::deserialize(Deserializer &deserializer) {
2740+
Circuit::BlackBoxOp::PedersenHash obj;
26332741
obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
26342742
obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
26352743
obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);

‎acvm-repo/acir/src/circuit/black_box_functions.rs‎

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,9 @@ pub enum BlackBoxFunc {
3030
/// [grumpkin]: https://hackmd.io/@aztec-network/ByzgNxBfd#2-Grumpkin---A-curve-on-top-of-BN-254-for-SNARK-efficient-group-operations
3131
SchnorrVerify,
3232
/// Calculates a Pedersen commitment to the inputs.
33-
Pedersen,
33+
PedersenCommitment,
34+
/// Calculates a Pedersen hash to the inputs.
35+
PedersenHash,
3436
/// Hashes a set of inputs and applies the field modulus to the result
3537
/// to return a value which can be represented as a [`FieldElement`][acir_field::FieldElement]
3638
///
@@ -62,7 +64,8 @@ impl BlackBoxFunc {
6264
BlackBoxFunc::SHA256 => "sha256",
6365
BlackBoxFunc::SchnorrVerify => "schnorr_verify",
6466
BlackBoxFunc::Blake2s => "blake2s",
65-
BlackBoxFunc::Pedersen => "pedersen",
67+
BlackBoxFunc::PedersenCommitment => "pedersen",
68+
BlackBoxFunc::PedersenHash => "pedersen_hash",
6669
BlackBoxFunc::HashToField128Security => "hash_to_field_128_security",
6770
BlackBoxFunc::EcdsaSecp256k1 => "ecdsa_secp256k1",
6871
BlackBoxFunc::FixedBaseScalarMul => "fixed_base_scalar_mul",
@@ -79,7 +82,8 @@ impl BlackBoxFunc {
7982
"sha256" => Some(BlackBoxFunc::SHA256),
8083
"schnorr_verify" => Some(BlackBoxFunc::SchnorrVerify),
8184
"blake2s" => Some(BlackBoxFunc::Blake2s),
82-
"pedersen" => Some(BlackBoxFunc::Pedersen),
85+
"pedersen" => Some(BlackBoxFunc::PedersenCommitment),
86+
"pedersen_hash" => Some(BlackBoxFunc::PedersenHash),
8387
"hash_to_field_128_security" => Some(BlackBoxFunc::HashToField128Security),
8488
"ecdsa_secp256k1" => Some(BlackBoxFunc::EcdsaSecp256k1),
8589
"ecdsa_secp256r1" => Some(BlackBoxFunc::EcdsaSecp256r1),

‎acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs‎

Lines changed: 19 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -46,11 +46,16 @@ pub enum BlackBoxFuncCall {
4646
message: Vec<FunctionInput>,
4747
output: Witness,
4848
},
49-
Pedersen {
49+
PedersenCommitment {
5050
inputs: Vec<FunctionInput>,
5151
domain_separator: u32,
5252
outputs: (Witness, Witness),
5353
},
54+
PedersenHash {
55+
inputs: Vec<FunctionInput>,
56+
domain_separator: u32,
57+
output: Witness,
58+
},
5459
// 128 here specifies that this function
5560
// should have 128 bits of security
5661
HashToField128Security {
@@ -138,11 +143,16 @@ impl BlackBoxFuncCall {
138143
message: vec![],
139144
output: Witness(0),
140145
},
141-
BlackBoxFunc::Pedersen => BlackBoxFuncCall::Pedersen {
146+
BlackBoxFunc::PedersenCommitment => BlackBoxFuncCall::PedersenCommitment {
142147
inputs: vec![],
143148
domain_separator: 0,
144149
outputs: (Witness(0), Witness(0)),
145150
},
151+
BlackBoxFunc::PedersenHash => BlackBoxFuncCall::PedersenHash {
152+
inputs: vec![],
153+
domain_separator: 0,
154+
output: Witness(0),
155+
},
146156
BlackBoxFunc::HashToField128Security => {
147157
BlackBoxFuncCall::HashToField128Security { inputs: vec![], output: Witness(0) }
148158
}
@@ -187,7 +197,8 @@ impl BlackBoxFuncCall {
187197
BlackBoxFuncCall::SHA256 { .. } => BlackBoxFunc::SHA256,
188198
BlackBoxFuncCall::Blake2s { .. } => BlackBoxFunc::Blake2s,
189199
BlackBoxFuncCall::SchnorrVerify { .. } => BlackBoxFunc::SchnorrVerify,
190-
BlackBoxFuncCall::Pedersen { .. } => BlackBoxFunc::Pedersen,
200+
BlackBoxFuncCall::PedersenCommitment { .. } => BlackBoxFunc::PedersenCommitment,
201+
BlackBoxFuncCall::PedersenHash { .. } => BlackBoxFunc::PedersenHash,
191202
BlackBoxFuncCall::HashToField128Security { .. } => BlackBoxFunc::HashToField128Security,
192203
BlackBoxFuncCall::EcdsaSecp256k1 { .. } => BlackBoxFunc::EcdsaSecp256k1,
193204
BlackBoxFuncCall::EcdsaSecp256r1 { .. } => BlackBoxFunc::EcdsaSecp256r1,
@@ -207,7 +218,8 @@ impl BlackBoxFuncCall {
207218
BlackBoxFuncCall::SHA256 { inputs, .. }
208219
| BlackBoxFuncCall::Blake2s { inputs, .. }
209220
| BlackBoxFuncCall::Keccak256 { inputs, .. }
210-
| BlackBoxFuncCall::Pedersen { inputs, .. }
221+
| BlackBoxFuncCall::PedersenCommitment { inputs, .. }
222+
| BlackBoxFuncCall::PedersenHash { inputs, .. }
211223
| BlackBoxFuncCall::HashToField128Security { inputs, .. } => inputs.to_vec(),
212224
BlackBoxFuncCall::AND { lhs, rhs, .. } | BlackBoxFuncCall::XOR { lhs, rhs, .. } => {
213225
vec![*lhs, *rhs]
@@ -304,9 +316,10 @@ impl BlackBoxFuncCall {
304316
| BlackBoxFuncCall::HashToField128Security { output, .. }
305317
| BlackBoxFuncCall::SchnorrVerify { output, .. }
306318
| BlackBoxFuncCall::EcdsaSecp256k1 { output, .. }
319+
| BlackBoxFuncCall::PedersenHash { output, .. }
307320
| BlackBoxFuncCall::EcdsaSecp256r1 { output, .. } => vec![*output],
308321
BlackBoxFuncCall::FixedBaseScalarMul { outputs, .. }
309-
| BlackBoxFuncCall::Pedersen { outputs, .. } => vec![outputs.0, outputs.1],
322+
| BlackBoxFuncCall::PedersenCommitment { outputs, .. } => vec![outputs.0, outputs.1],
310323
BlackBoxFuncCall::RANGE { .. } => vec![],
311324
BlackBoxFuncCall::Keccak256VariableLength { outputs, .. } => outputs.to_vec(),
312325
}
@@ -395,7 +408,7 @@ impl std::fmt::Display for BlackBoxFuncCall {
395408

396409
// SPECIFIC PARAMETERS
397410
match self {
398-
BlackBoxFuncCall::Pedersen { domain_separator, .. } => {
411+
BlackBoxFuncCall::PedersenCommitment { domain_separator, .. } => {
399412
write!(f, " domain_separator: {domain_separator}")
400413
}
401414
_ => write!(f, ""),

0 commit comments

Comments
 (0)