feat: add poseidon relations to UltraKeccak flavor and Solidity verifier

barretenberg/acir_tests/flows/honk_sol.sh

@@ -19,7 +19,7 @@ export VERIFIER_PATH="$(pwd)/Verifier.sol"
 export TEST_PATH=$(realpath "../../sol-test/HonkTest.sol")
 export TESTING_HONK="true"
 
-# Use solcjs to compile the generated key contract with the template verifier and test contract 
+# Use solcjs to compile the generated key contract with the template verifier and test contract
 # index.js will start an anvil, on a random port
 # Deploy the verifier then send a test transaction
 export TEST_NAME=$(basename $(pwd))

barretenberg/acir_tests/sol-test/src/index.js

@@ -3,9 +3,11 @@ const { readFileSync, promises: fsPromises } = fs;
 import { spawn } from "child_process";
 import { ethers } from "ethers";
 import solc from "solc";
+import linker from "solc/linker.js";
 
 const NUMBER_OF_FIELDS_IN_PLONK_PROOF = 93;
-const NUMBER_OF_FIELDS_IN_HONK_PROOF = 393;
+// This excludes the public inputs which are sent separately to the Solidity verifier
+const NUMBER_OF_FIELDS_IN_HONK_PROOF = 423;
 
 // We use the solcjs compiler version in this test, although it is slower than foundry, to run the test end to end
 // it simplifies of parallelising the test suite
@@ -47,6 +49,9 @@ const [test, verifier] = await Promise.all([
   fsPromises.readFile(verifierPath, encoding),
 ]);
 
+// 1. figure out how to deploy the libraries
+// 2. call linker.linkBytecode providing the libraries name and address
+
 export const compilationInput = {
   language: "Solidity",
   sources: {
@@ -73,28 +78,26 @@ export const compilationInput = {
 
 // If testing honk is set, then we compile the honk test suite
 const testingHonk = getEnvVarCanBeUndefined("TESTING_HONK");
-const NUMBER_OF_FIELDS_IN_PROOF = testingHonk ? NUMBER_OF_FIELDS_IN_HONK_PROOF : NUMBER_OF_FIELDS_IN_PLONK_PROOF;
+const NUMBER_OF_FIELDS_IN_PROOF = testingHonk
+  ? NUMBER_OF_FIELDS_IN_HONK_PROOF
+  : NUMBER_OF_FIELDS_IN_PLONK_PROOF;
 if (!testingHonk) {
+  const keyPath = getEnvVar("KEY_PATH");
+  const basePath = getEnvVar("BASE_PATH");
+  const [key, base] = await Promise.all([
+    fsPromises.readFile(keyPath, encoding),
+    fsPromises.readFile(basePath, encoding),
+  ]);
 
-    const keyPath = getEnvVar("KEY_PATH");
-    const basePath = getEnvVar("BASE_PATH");
-    const [key, base] = await Promise.all(
-      [
-        fsPromises.readFile(keyPath, encoding),
-        fsPromises.readFile(basePath, encoding),
-      ]
-    );
-
-    compilationInput.sources["BaseUltraVerifier.sol"] = {
-      content: base,
-    };
-    compilationInput.sources["Key.sol"] = {
-      content: key,
-    };
+  compilationInput.sources["BaseUltraVerifier.sol"] = {
+    content: base,
+  };
+  compilationInput.sources["Key.sol"] = {
+    content: key,
+  };
 }
 
 var output = JSON.parse(solc.compile(JSON.stringify(compilationInput)));
-
 const contract = output.contracts["Test.sol"]["Test"];
 const bytecode = contract.evm.bytecode.object;
 const abi = contract.abi;
@@ -133,7 +136,7 @@ const launchAnvil = async (port) => {
  * Deploys the contract
  * @param {ethers.Signer} signer
  */
-const deploy = async (signer) => {
+const deploy = async (signer, abi, bytecode) => {
   const factory = new ethers.ContractFactory(abi, bytecode, signer);
   const deployment = await factory.deploy();
   const deployed = await deployment.waitForDeployment();
@@ -147,14 +150,14 @@ const deploy = async (signer) => {
  */
 const readPublicInputs = (proofAsFields) => {
   const publicInputs = [];
-  // A proof with no public inputs is 93 fields long
+  // Compute the number of public inputs, not accounted  for in the constant NUMBER_OF_FIELDS_IN_PROOF
   const numPublicInputs = proofAsFields.length - NUMBER_OF_FIELDS_IN_PROOF;
   let publicInputsOffset = 0;
-  
+
   // Honk proofs contain 3 pieces of metadata before the public inputs, while plonk does not
   if (testingHonk) {
     publicInputsOffset = 3;
-  } 
+  }
 
   for (let i = 0; i < numPublicInputs; i++) {
     publicInputs.push(proofAsFields[publicInputsOffset + i]);
@@ -215,7 +218,7 @@ try {
     proofStr = proofStr.substring(8);
     // Get the part before and after the public inputs
     const proofStart = proofStr.slice(0, 64 * 3);
-    const proofEnd = proofStr.substring((64 * 3) + (64 * numPublicInputs));
+    const proofEnd = proofStr.substring(64 * 3 + 64 * numPublicInputs);
     proofStr = proofStart + proofEnd;
   } else {
     proofStr = proofStr.substring(64 * numPublicInputs);
@@ -228,8 +231,63 @@ try {
   const provider = await getProvider(randomPort);
   const signer = new ethers.Wallet(key, provider);
 
-  // deploy
-  const address = await deploy(signer);
+  // if testing honk we need to link the external libraries to the contract's bytecode before deploying it, otherise we can just deploy the contract directly
+  // note ABI stays unchanged
+  const getDeployedContractAdress = async () => {
+    if (testingHonk) {
+      // Get the bytecode and abi of the two libraries with external calls that need to be deployed separately
+      const transcriptLib = output.contracts["Verifier.sol"]["TranscriptLib"];
+      const transcriptLibBytecode = transcriptLib.evm.bytecode.object;
+      const transcriptLibAbi = transcriptLib.abi;
+
+      const relationsLib = output.contracts["Verifier.sol"]["RelationsLib"];
+      const relationsLibBytecode = relationsLib.evm.bytecode.object;
+      const relationsLibAbi = relationsLib.abi;
+
+      // Deploy the two libraries, awaiting to ensure the nonce is modified correctly to prevent race conditions.
+      console.log(await signer.getNonce());
+      const transcriptLibAddress = await deploy(
+        signer,
+        transcriptLibAbi,
+        transcriptLibBytecode
+      );
+
+      // TODO: maybe this can be done in a better way
+      console.log(await signer.getNonce());
+
+      const relationsLibAddress = await deploy(
+        signer,
+        relationsLibAbi,
+        relationsLibBytecode
+      );
+
+      const libraries = {
+        TranscriptLib: transcriptLibAddress,
+        RelationsLib: relationsLibAddress,
+      };
+      const linkerInput = {
+        "Verifier.sol": {
+          TranscriptLib: libraries["TranscriptLib"],
+          RelationsLib: libraries["RelationsLib"],
+        },
+      };
+
+      // Link the libraries in the contract bytecode
+      const linkedBytecode = linker.linkBytecode(bytecode, linkerInput);
+
+      console.log(await signer.getNonce());
+
+      // Deploy the verifier contract
+      const address = await deploy(signer, abi, linkedBytecode);
+      return address;
+    } else {
+      const address = await deploy(signer, abi, bytecode);
+      return address;
+    }
+  };
+
+  const address = await getDeployedContractAdress();
+
   const contract = new ethers.Contract(address, abi, signer);
 
   const result = await contract.test(proofStr, publicInputs);

barretenberg/cpp/src/barretenberg/bb/main.cpp

@@ -10,7 +10,7 @@
 #include "barretenberg/serialize/cbind.hpp"
 #include "barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.hpp"
 #include "barretenberg/stdlib_circuit_builders/ultra_flavor.hpp"
-#include "barretenberg/stdlib_circuit_builders/ultra_keccak.hpp"
+#include "barretenberg/stdlib_circuit_builders/ultra_keccak_flavor.hpp"
 
 #include <cstddef>
 #ifndef DISABLE_AZTEC_VM
@@ -1085,7 +1085,6 @@ void prove_honk(const std::string& bytecodePath, const std::string& witnessPath,
     // Construct Honk proof
     Prover prover = compute_valid_prover<Flavor>(bytecodePath, witnessPath);
     auto proof = prover.construct_proof();
-
     if (outputPath == "-") {
         writeRawBytesToStdout(to_buffer</*include_size=*/true>(proof));
         vinfo("proof written to stdout");