chore!: Replace computing hashes in circuits wasm, with computing them in ts via bb.js pedersen call.

.circleci/config.yml

@@ -1238,6 +1238,7 @@ workflows:
           requires:
             - circuits-wasm-linux-clang
             - l1-contracts
+            - bb-js
           <<: *defaults
       - yarn-project:
           requires:

barretenberg/cpp/src/barretenberg/barretenberg.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 // External Barretenberg C++ API
+#include "common/bbmalloc.hpp"
 #include "common/container.hpp"
 #include "common/map.hpp"
 #include "common/mem.hpp"

barretenberg/cpp/src/barretenberg/common/mem.cpp → barretenberg/cpp/src/barretenberg/common/bbmalloc.cpp

@@ -1,6 +1,5 @@
-#include "./mem.hpp"
+#include "./bbmalloc.hpp"
 #include "./slab_allocator.hpp"
-#include "./wasm_export.hpp"
 
 WASM_EXPORT void* bbmalloc(size_t size)
 {

barretenberg/cpp/src/barretenberg/common/bbmalloc.hpp

@@ -0,0 +1,7 @@
+#pragma once
+#include "./wasm_export.hpp"
+#include <cstddef>
+
+WASM_EXPORT void* bbmalloc(size_t size);
+
+WASM_EXPORT void bbfree(void* ptr);

barretenberg/cpp/src/barretenberg/common/mem.hpp

@@ -75,7 +75,4 @@ inline void aligned_free(void* mem)
 //     info("Total allocated space (uordblks): ", minfo.uordblks);
 //     info("Total free space (fordblks): ", minfo.fordblks);
 //     info("Top-most, releasable space (keepcost): ", minfo.keepcost);
-// }
-
-WASM_EXPORT void* bbmalloc(size_t size);
-WASM_EXPORT void bbfree(void* ptr);
+// }

barretenberg/cpp/src/barretenberg/crypto/pedersen_commitment/c_bind.cpp

@@ -3,11 +3,16 @@
 #include "barretenberg/common/serialize.hpp"
 #include "pedersen.hpp"
 
-WASM_EXPORT void pedersen__commit(uint8_t const* inputs_buffer, uint8_t* output)
+extern "C" {
+
+using namespace barretenberg;
+
+WASM_EXPORT void pedersen_commit(fr::vec_in_buf inputs_buffer, affine_element::out_buf output)
 {
     std::vector<grumpkin::fq> to_commit;
     read(inputs_buffer, to_commit);
     grumpkin::g1::affine_element pedersen_commitment = crypto::pedersen_commitment::commit_native(to_commit);
 
     serialize::write(output, pedersen_commitment);
+}
 }

barretenberg/cpp/src/barretenberg/crypto/pedersen_commitment/c_bind.hpp

@@ -1,7 +1,12 @@
 #pragma once
-#include "barretenberg/common/mem.hpp"
-#include "barretenberg/common/serialize.hpp"
-#include "barretenberg/common/streams.hpp"
-#include "barretenberg/common/timer.hpp"
+#include "barretenberg/common/wasm_export.hpp"
+#include "barretenberg/ecc/curves/bn254/fr.hpp"
+#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 
-WASM_EXPORT void pedersen__commit(uint8_t const* inputs_buffer, uint8_t* output);
+extern "C" {
+
+using namespace barretenberg;
+using affine_element = grumpkin::g1::affine_element;
+
+WASM_EXPORT void pedersen_commit(fr::vec_in_buf inputs_buffer, affine_element::out_buf output);
+}

barretenberg/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen.test.cpp

@@ -1,4 +1,5 @@
 #include "pedersen.hpp"
+#include "barretenberg/common/timer.hpp"
 #include "barretenberg/crypto/generators/generator_data.hpp"
 #include <gtest/gtest.h>
 
@@ -16,4 +17,38 @@ TEST(Pedersen, Commitment)
     EXPECT_EQ(r, expected);
 }
 
-} // namespace crypto
+TEST(Pedersen, CommitmentWithZero)
+{
+    auto x = pedersen_commitment::Fq::zero();
+    auto y = pedersen_commitment::Fq::one();
+    auto r = pedersen_commitment::commit_native({ x, y });
+    auto expected =
+        grumpkin::g1::affine_element(fr(uint256_t("054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402")),
+                                     fr(uint256_t("209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126")));
+    EXPECT_EQ(r, expected);
+}
+
+TEST(Pedersen, CommitmentProf)
+{
+    GTEST_SKIP() << "Skipping mini profiler.";
+    auto x = fr::random_element();
+    auto y = fr::random_element();
+    Timer t;
+    for (int i = 0; i < 10000; ++i) {
+        pedersen_commitment::commit_native({ x, y });
+    }
+    info(t.nanoseconds() / 1000 / 10000);
+}
+
+// Useful for pasting into ts version of pedersen.
+TEST(Pedersen, GeneratorPrinter)
+{
+    GTEST_SKIP() << "Skipping generator-for-ts printer.";
+    pedersen_commitment::GeneratorContext ctx;
+    auto generators = ctx.generators->get_default_generators()->get(128);
+    for (auto g : generators) {
+        info("[", g.x, "n, ", g.y, "n],");
+    }
+}
+
+}; // namespace crypto

barretenberg/cpp/src/barretenberg/crypto/pedersen_hash/c_bind.cpp

@@ -5,12 +5,12 @@
 
 extern "C" {
 
-WASM_EXPORT void pedersen__hash_with_hash_index(uint8_t const* inputs_buffer, uint32_t hash_index, uint8_t* output)
+WASM_EXPORT void pedersen_hash(uint8_t const* inputs_buffer, uint32_t const* hash_index, uint8_t* output)
 {
     std::vector<grumpkin::fq> to_hash;
     read(inputs_buffer, to_hash);
     crypto::GeneratorContext<curve::Grumpkin> ctx;
-    ctx.offset = static_cast<size_t>(hash_index);
+    ctx.offset = static_cast<size_t>(ntohl(*hash_index));
     auto r = crypto::pedersen_hash::hash(to_hash, ctx);
     barretenberg::fr::serialize_to_buffer(r, output);
 }

barretenberg/cpp/src/barretenberg/crypto/pedersen_hash/c_bind.hpp

@@ -7,7 +7,5 @@ extern "C" {
 
 using namespace barretenberg;
 
-WASM_EXPORT void pedersen_hash_with_hash_index(fr::vec_in_buf inputs_buffer,
-                                               uint32_t const* hash_index,
-                                               fr::out_buf output);
+WASM_EXPORT void pedersen_hash(fr::vec_in_buf inputs_buffer, uint32_t const* hash_index, fr::out_buf output);
 }

barretenberg/cpp/src/barretenberg/crypto/schnorr/c_bind.hpp

@@ -17,7 +17,7 @@ WASM_EXPORT void schnorr_construct_signature(uint8_t const* message, fr::in_buf
 WASM_EXPORT void schnorr_verify_signature(
     uint8_t const* message, affine_element::in_buf pub_key, in_buf32 sig_s, in_buf32 sig_e, bool* result);
 
-WASM_EXPORT void schnorr_multisig_create_multisig_public_key(fq::in_buf private_key,
+WASM_EXPORT void schnorr_multisig_create_multisig_public_key(fr::in_buf private_key,
                                                              multisig::MultiSigPublicKey::out_buf multisig_pubkey_buf);
 
 WASM_EXPORT void schnorr_multisig_validate_and_combine_signer_pubkeys(
@@ -29,11 +29,11 @@ WASM_EXPORT void schnorr_multisig_construct_signature_round_1(
 
 WASM_EXPORT void schnorr_multisig_construct_signature_round_2(
     uint8_t const* message,
-    fq::in_buf private_key,
+    fr::in_buf private_key,
     multisig::RoundOnePrivateOutput::in_buf signer_round_one_private_buf,
     multisig::MultiSigPublicKey::vec_in_buf signer_pubkeys_buf,
     multisig::RoundOnePublicOutput::vec_in_buf round_one_public_buf,
-    fq::out_buf round_two_buf,
+    fr::out_buf round_two_buf,
     bool* success);
 
 WASM_EXPORT void schnorr_multisig_combine_signatures(uint8_t const* message,

barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.test.cpp

@@ -1,6 +1,6 @@
 #include "barretenberg/crypto/pedersen_commitment/pedersen.hpp"
 #include "barretenberg/common/test.hpp"
-#include "barretenberg/crypto/pedersen_commitment/c_bind_new.hpp"
+#include "barretenberg/crypto/pedersen_commitment/c_bind.hpp"
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "barretenberg/numeric/random/engine.hpp"
 #include "barretenberg/stdlib/primitives/curves/bn254.hpp"

barretenberg/exports.json

@@ -1,6 +1,6 @@
 [
   {
-    "functionName": "pedersen___commit",
+    "functionName": "pedersen_commit",
     "inArgs": [
       {
         "name": "inputs_buffer",
@@ -16,7 +16,7 @@
     "isAsync": false
   },
   {
-    "functionName": "pedersen_hash_with_hash_index",
+    "functionName": "pedersen_hash",
     "inArgs": [
       {
         "name": "inputs_buffer",
@@ -156,7 +156,7 @@
     "inArgs": [
       {
         "name": "private_key",
-        "type": "fq::in_buf"
+        "type": "fr::in_buf"
       }
     ],
     "outArgs": [
@@ -211,7 +211,7 @@
       },
       {
         "name": "private_key",
-        "type": "fq::in_buf"
+        "type": "fr::in_buf"
       },
       {
         "name": "signer_round_one_private_buf",
@@ -229,7 +229,7 @@
     "outArgs": [
       {
         "name": "round_two_buf",
-        "type": "fq::out_buf"
+        "type": "fr::out_buf"
       },
       {
         "name": "success",

barretenberg/scripts/c_bind_files.txt

@@ -1,4 +1,4 @@
-./cpp/src/barretenberg/crypto/pedersen_commitment/c_bind_new.hpp
+./cpp/src/barretenberg/crypto/pedersen_commitment/c_bind.hpp
 ./cpp/src/barretenberg/crypto/pedersen_hash/c_bind.hpp
 ./cpp/src/barretenberg/crypto/blake2s/c_bind.hpp
 ./cpp/src/barretenberg/crypto/schnorr/c_bind.hpp

barretenberg/scripts/decls_json.py

@@ -33,13 +33,6 @@ def process_files(files: List[str]) -> List[dict]:
     idx = clang.cindex.Index.create()
     for path in files:
         tu = idx.parse(path, args=[
-            '-isystem', '/usr/include/c++/10',
-            '-isystem', '/usr/include/x86_64-linux-gnu/c++/10',
-            '-isystem', '/usr/include/c++/10/backward',
-            '-isystem', '/usr/lib/llvm-15/lib/clang/15.0.7/include',
-            '-isystem', '/usr/local/include',
-            '-isystem', '/usr/include/x86_64-linux-gnu',
-            '-isystem', '/usr/include',
             "-I./cpp/src",
             '-std=gnu++20', '-Wall', '-Wextra'])
         for diag in tu.diagnostics:

barretenberg/ts/src/barretenberg_api/index.ts

@@ -18,12 +18,12 @@ export class BarretenbergApi {
   }
 
   async pedersenCommit(inputsBuffer: Fr[]): Promise<Point> {
-    const result = await this.binder.callWasmExport('pedersen___commit', [inputsBuffer], [Point]);
+    const result = await this.binder.callWasmExport('pedersen_commit', [inputsBuffer], [Point]);
     return result[0];
   }
 
-  async pedersenHashWithHashIndex(inputsBuffer: Fr[], hashIndex: number): Promise<Fr> {
-    const result = await this.binder.callWasmExport('pedersen_hash_with_hash_index', [inputsBuffer, hashIndex], [Fr]);
+  async pedersenHash(inputsBuffer: Fr[], hashIndex: number): Promise<Fr> {
+    const result = await this.binder.callWasmExport('pedersen_hash', [inputsBuffer, hashIndex], [Fr]);
     return result[0];
   }
 
@@ -65,7 +65,7 @@ export class BarretenbergApi {
     return result[0];
   }
 
-  async schnorrMultisigCreateMultisigPublicKey(privateKey: Fq): Promise<Buffer128> {
+  async schnorrMultisigCreateMultisigPublicKey(privateKey: Fr): Promise<Buffer128> {
     const result = await this.binder.callWasmExport(
       'schnorr_multisig_create_multisig_public_key',
       [privateKey],
@@ -94,15 +94,15 @@ export class BarretenbergApi {
 
   async schnorrMultisigConstructSignatureRound2(
     message: Uint8Array,
-    privateKey: Fq,
+    privateKey: Fr,
     signerRoundOnePrivateBuf: Buffer128,
     signerPubkeysBuf: Buffer128[],
     roundOnePublicBuf: Buffer128[],
-  ): Promise<[Fq, boolean]> {
+  ): Promise<[Fr, boolean]> {
     const result = await this.binder.callWasmExport(
       'schnorr_multisig_construct_signature_round_2',
       [message, privateKey, signerRoundOnePrivateBuf, signerPubkeysBuf, roundOnePublicBuf],
-      [Fq, BoolDeserializer()],
+      [Fr, BoolDeserializer()],
     );
     return result as any;
   }

barretenberg/ts/src/barretenberg_wasm/barretenberg_wasm_base/index.ts

@@ -4,6 +4,10 @@ import { killSelf } from '../helpers/index.js';
 
 const debug = createDebug('bb.js:wasm');
 
+/**
+ * Base implementation of BarretenbergWasm.
+ * Contains code that is common to the "main thread" implementation and the "child thread" implementation.
+ */
 export class BarretenbergWasmBase {
   protected memStore: { [key: string]: Uint8Array } = {};
   protected memory!: WebAssembly.Memory;