chore: improve testing (#19)

Author: jialinli98

.github/workflows/test.yml

@@ -8,7 +8,7 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
-  MINIMUM_NOIR_VERSION: v0.36.0
+  MINIMUM_NOIR_VERSION: v1.0.0
 
 jobs:
   noir-version-list:
@@ -61,43 +61,6 @@ jobs:
       - name: Run all tests (including oracle tests)
         working-directory: ./scripts
         run: ./run.sh
-  rust-equivalence-tests:
-    name: Test for equivalence against Rust impl
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v4
-
-      - name: Install Nargo
-        uses: noir-lang/[email protected]
-        with:
-          toolchain: v0.36.0
-
-      - name: Install Cargo
-        uses: dtolnay/[email protected]
-        with:
-          targets: x86_64-unknown-linux-gnu
-      
-      - name: Cache Cargo dependencies
-        uses: Swatinem/rust-cache@v2
-        with:
-          key: x86_64-unknown-linux-gnu
-          cache-on-failure: true
-      
-      - name: Setup Node.js and install dependencies
-        uses: actions/setup-node@v4
-        with:
-          node-version: 22.15.0
-          cache: 'yarn'
-          cache-dependency-path: 'yarn.lock'
-      
-      - name: Install dependencies
-        run: |
-          yarn --immutable
-
-      - name: Export and Test Noir Functions
-        working-directory: ./scripts
-        run: ./run.sh
 
   format:
     runs-on: ubuntu-latest

.gitignore

@@ -3,3 +3,4 @@ node_modules
 target
 export
 gates_report.json
+package-lock.json

README.md

@@ -4,7 +4,7 @@ This package contains the Poseidon hashing interface, formerly in the Noir stand
 
 ## Noir version compatibility
 
-This library is tested to work as of Noir version 0.36.0.
+This library is tested to work as of Noir version 1.0.0.
 
 ## Benchmarks
 

oracle_server.ts

@@ -4,6 +4,7 @@ import { BarretenbergSync, Fr } from "@aztec/bb.js";
 import express, { Request, Response } from "express";
 import bodyParser from "body-parser";
 import cors from "cors";
+import { poseidon1, poseidon2, poseidon3, poseidon4, poseidon5, poseidon6, poseidon7, poseidon8, poseidon9, poseidon10, poseidon11, poseidon12, poseidon13, poseidon14, poseidon15, poseidon16 } from "poseidon-lite";
 
 // Type definitions
 interface JsonRpcRequest {
@@ -98,10 +99,12 @@ app.post("/", async (req: Request<{}, JsonRpcResponse, JsonRpcRequest>, res: Res
 async function handleForeignCall(params: any[]): Promise<ForeignCallResult> {
   const [callInfo] = params as [ForeignCallInfo];
   const { function: functionName, inputs } = callInfo;
-  
-  
+
+
   if (functionName === "getPoseidon2Hash") {
     return await handlePoseidon2Hash(inputs);
+  } else if (functionName === "getPoseidonHash") {
+    return await handlePoseidonHash(inputs);
   } else {
     throw new Error(`Unknown oracle function: ${functionName}`);
   }
@@ -121,25 +124,77 @@ function hexToBigInt(hex: string): bigint {
 
 async function handlePoseidon2Hash(inputs: string[][]): Promise<ForeignCallResult> {
   try {
-    // Extract the input array from the first parameter
-    const inputArray = inputs[0] || [];
-    
-    const fieldInputs: Fr[] = inputArray.map((input: string) => new Fr(hexToBigInt(input)))
-    
-    // Perform Poseidon2 hash using bb.js
-    let result: Fr;
-    if (fieldInputs.length === 0) {
-      // Empty input case
-      result = await bb.poseidon2Hash([]);
-    } else {
-      result = await bb.poseidon2Hash(fieldInputs);
+    // For dynamic slices [Field], Noir sends:
+    // inputs[0] = array length (metadata)
+    // inputs[1] = array contents
+    // inputs[2] = message_size
+
+    const inputArray = inputs[1] || [];
+
+    // For u32, Noir sends as strings, not arrays
+    const messageSizeHex = inputs[2] as unknown as string;
+    if (!messageSizeHex) {
+      throw new Error("message_size parameter is missing");
     }
-    
-    
+    const messageSize = Number(hexToBigInt(messageSizeHex));
+
+    // Convert input array to Field elements
+    const fieldInputs: Fr[] = inputArray.map((input: string) => new Fr(hexToBigInt(input)));
+
+    // Slice to only use the first message_size elements
+    const slicedInputs = fieldInputs.slice(0, messageSize);
+
+    // Get Poseidon2 hash using bb.js
+    const result = bb.poseidon2Hash(slicedInputs);
+
     return {
       values: [result.toString()]
     };
-    
+
+  } catch (error) {
+    throw error;
+  }
+}
+
+async function handlePoseidonHash(inputs: string[][]): Promise<ForeignCallResult> {
+  try {
+
+    // Extract the input array from the second parameter (inputs[1])
+    const inputArray = inputs[1] || [];
+
+    // Extract message_size from the third parameter (inputs[2])
+    const messageSizeHex = inputs[2] as unknown as string;
+    if (!messageSizeHex) {
+      throw new Error("message_size parameter is missing");
+    }
+    const messageSize = Number(hexToBigInt(messageSizeHex));
+
+    if (messageSize < 1 || messageSize > 16) {
+      throw new Error(`message_size must be between 1 and 16, got ${messageSize}`);
+    }
+
+    // Convert input array to BigInt array, slicing to message_size
+    const bigIntInputs: bigint[] = inputArray
+      .slice(0, messageSize)
+      .map((input: string) => hexToBigInt(input));
+
+    // Map to appropriate poseidon function
+    const poseidonFunctions = [
+      poseidon1, poseidon2, poseidon3, poseidon4, poseidon5, poseidon6,
+      poseidon7, poseidon8, poseidon9, poseidon10, poseidon11, poseidon12,
+      poseidon13, poseidon14, poseidon15, poseidon16
+    ];
+
+    const poseidonFunc = poseidonFunctions[messageSize - 1];
+    if (!poseidonFunc) {
+      throw new Error(`No poseidon function available for message_size ${messageSize}`);
+    }
+    const result = poseidonFunc(bigIntInputs);
+
+    return {
+      values: ["0x" + result.toString(16)]
+    };
+
   } catch (error) {
     throw error;
   }

package.json

@@ -16,7 +16,8 @@
     "@aztec/bb.js": "^1.2.1",
     "body-parser": "^1.20.2",
     "cors": "^2.8.5",
-    "express": "^4.18.2"
+    "express": "^4.18.2",
+    "poseidon-lite": "^0.3.0"
   },
   "devDependencies": {
     "@types/body-parser": "^1.19.2",

scripts/run.sh

@@ -11,7 +11,7 @@ yarn build
 echo "Starting TypeScript RPC server..."
 yarn start &
 TS_SERVER_PID=$!
-trap 'kill $TS_SERVER_PID' EXIT
+trap 'kill $TS_SERVER_PID 2>/dev/null || true' EXIT
 
 # Wait for server to start
 sleep 2

src/oracle_tests.nr

@@ -1,20 +1,130 @@
-use super::poseidon2;
+use super::{poseidon, poseidon2};
 
 /// This calls the bb.js Poseidon2 implementation
 #[oracle(getPoseidon2Hash)]
-unconstrained fn poseidon2_hash_oracle(input: [Field; 10]) -> Field {}
+unconstrained fn get_poseidon2_hash(input: [Field], message_size: u32) -> Field {}
 
-unconstrained fn get_poseidon2_hash(input: [Field; 10]) -> Field {
-    poseidon2_hash_oracle(input)
+/// This calls the poseidon-lite Poseidon implementation
+#[oracle(getPoseidonHash)]
+unconstrained fn get_poseidon_hash(input: [Field], message_size: u32) -> Field {}
+
+#[test]
+unconstrained fn test_poseidon2(input: [Field; 20]) {
+    for i in 0..=20 {
+        // get hash from Noir implementation
+        let temp_size = i % (input.len() + 1);
+        let noir_hash = poseidon2::Poseidon2::hash(input, temp_size);
+
+        // get hash from bb.js via oracle
+        let bb_hash = get_poseidon2_hash(input, temp_size);
+
+        assert_eq(noir_hash, bb_hash);
+    }
+}
+
+// Poseidon (original) oracle tests
+
+#[test]
+unconstrained fn test_poseidon_hash_1(input: [Field; 1]) {
+    let noir_hash = poseidon::bn254::hash_1(input);
+    let oracle_hash = get_poseidon_hash(input, 1);
+    assert_eq(noir_hash, oracle_hash);
+}
+
+#[test]
+unconstrained fn test_poseidon_hash_2(input: [Field; 2]) {
+    let noir_hash = poseidon::bn254::hash_2(input);
+    let oracle_hash = get_poseidon_hash(input, 2);
+    assert_eq(noir_hash, oracle_hash);
 }
 
 #[test]
-unconstrained fn test_poseidon2(input: [Field; 10]) {
-    // get hash from Noir implementation
-    let noir_hash = poseidon2::Poseidon2::hash(input, input.len());
+unconstrained fn test_poseidon_hash_3(input: [Field; 3]) {
+    let noir_hash = poseidon::bn254::hash_3(input);
+    let oracle_hash = get_poseidon_hash(input, 3);
+    assert_eq(noir_hash, oracle_hash);
+}
 
-    // get hash from bb.js via oracle
-    let bb_hash = get_poseidon2_hash(input);
+#[test]
+unconstrained fn test_poseidon_hash_4(input: [Field; 4]) {
+    let noir_hash = poseidon::bn254::hash_4(input);
+    let oracle_hash = get_poseidon_hash(input, 4);
+    assert_eq(noir_hash, oracle_hash);
+}
+
+#[test]
+unconstrained fn test_poseidon_hash_5(input: [Field; 5]) {
+    let noir_hash = poseidon::bn254::hash_5(input);
+    let oracle_hash = get_poseidon_hash(input, 5);
+    assert_eq(noir_hash, oracle_hash);
+}
+
+#[test]
+unconstrained fn test_poseidon_hash_6(input: [Field; 6]) {
+    let noir_hash = poseidon::bn254::hash_6(input);
+    let oracle_hash = get_poseidon_hash(input, 6);
+    assert_eq(noir_hash, oracle_hash);
+}
+
+#[test]
+unconstrained fn test_poseidon_hash_7(input: [Field; 7]) {
+    let noir_hash = poseidon::bn254::hash_7(input);
+    let oracle_hash = get_poseidon_hash(input, 7);
+    assert_eq(noir_hash, oracle_hash);
+}
 
-    assert_eq(noir_hash, bb_hash);
+#[test]
+unconstrained fn test_poseidon_hash_8(input: [Field; 8]) {
+    let noir_hash = poseidon::bn254::hash_8(input);
+    let oracle_hash = get_poseidon_hash(input, 8);
+    assert_eq(noir_hash, oracle_hash);
+}
+
+#[test]
+unconstrained fn test_poseidon_hash_9(input: [Field; 9]) {
+    let noir_hash = poseidon::bn254::hash_9(input);
+    let oracle_hash = get_poseidon_hash(input, 9);
+    assert_eq(noir_hash, oracle_hash);
+}
+
+#[test]
+unconstrained fn test_poseidon_hash_10(input: [Field; 10]) {
+    let noir_hash = poseidon::bn254::hash_10(input);
+    let oracle_hash = get_poseidon_hash(input, 10);
+    assert_eq(noir_hash, oracle_hash);
+}
+
+#[test]
+unconstrained fn test_poseidon_hash_11(input: [Field; 11]) {
+    let noir_hash = poseidon::bn254::hash_11(input);
+    let oracle_hash = get_poseidon_hash(input, 11);
+    assert_eq(noir_hash, oracle_hash);
+}
+
+#[test]
+unconstrained fn test_poseidon_hash_12(input: [Field; 12]) {
+    let noir_hash = poseidon::bn254::hash_12(input);
+    let oracle_hash = get_poseidon_hash(input, 12);
+    assert_eq(noir_hash, oracle_hash);
+}
+
+#[test]
+unconstrained fn test_poseidon_hash_13(input: [Field; 13]) {
+    let noir_hash = poseidon::bn254::hash_13(input);
+    let oracle_hash = get_poseidon_hash(input, 13);
+    assert_eq(noir_hash, oracle_hash);
+}
+
+#[test]
+unconstrained fn test_poseidon_hash_14(input: [Field; 14]) {
+    let noir_hash = poseidon::bn254::hash_14(input);
+    let oracle_hash = get_poseidon_hash(input, 14);
+    assert_eq(noir_hash, oracle_hash);
+}
+
+#[test]
+unconstrained fn test_poseidon_hash_15(input: [Field; 15]) {
+    let noir_hash = poseidon::bn254::hash_15(input);
+    let oracle_hash = get_poseidon_hash(input, 15);
+    assert_eq(noir_hash, oracle_hash);
 }

src/poseidon/mod.nr

@@ -52,7 +52,6 @@ pub fn permute<let T: u32, let N: u32, let X: u32>(
 ) -> [Field; T] {
     let PoseidonConfig { t, rf, rp, alpha, round_constants, mds, presparse_mds, sparse_mds } =
         pos_conf;
-
     for i in 0..state.len() {
         state[i] += round_constants[i];
     }

src/tests.nr

@@ -32,3 +32,36 @@ fn reference_impl_test_vectors() {
         );
     }
 }
+
+#[test]
+fn test_poseidon_hash_1() {
+    // Test hash_1 function
+    let input = [42];
+    let hash = poseidon::bn254::hash_1(input);
+    let expected = 0x1b408dafebeddf0871388399b1e53bd065fd70f18580be5cdde15d7eb2c52743;
+    assert_eq(hash, expected);
+}
+
+#[test]
+fn test_poseidon_hash_2() {
+    let input = [1, 2];
+    let hash = poseidon::bn254::hash_2(input);
+    let expected = 0x115cc0f5e7d690413df64c6b9662e9cf2a3617f2743245519e19607a4417189a;
+    assert_eq(hash, expected);
+}
+
+#[test]
+fn test_poseidon_hash_4() {
+    let input = [1, 2, 3, 4];
+    let hash = poseidon::bn254::hash_4(input);
+    let expected = 0x299c867db6c1fdd79dcefa40e4510b9837e60ebb1ce0663dbaa525df65250465;
+    assert_eq(hash, expected);
+}
+
+#[test]
+fn test_poseidon_hash_8() {
+    let input = [1, 2, 3, 4, 5, 6, 7, 8];
+    let hash = poseidon::bn254::hash_8(input);
+    let expected = 0x2921ab9bd0140cbc98e40395c0fefb40337a4d54fbbecd9a4d43b3d8d0c4d8d1;
+    assert_eq(hash, expected);
+}

yarn.lock

@@ -821,6 +821,11 @@ pino@^9.5.0:
     sonic-boom "^4.0.1"
     thread-stream "^3.0.0"
 
+poseidon-lite@^0.3.0:
+  version "0.3.0"
+  resolved "https://registry.yarnpkg.com/poseidon-lite/-/poseidon-lite-0.3.0.tgz#93c42f6f9b870f154f2722dfd686b909c4285765"
+  integrity sha512-ilJj4MIve4uBEG7SrtPqUUNkvpJ/pLVbndxa0WvebcQqeIhe+h72JR4g0EvwchUzm9sOQDlOjiDNmRAgxNZl4A==
+
 process-warning@^5.0.0:
   version "5.0.0"
   resolved "https://registry.yarnpkg.com/process-warning/-/process-warning-5.0.0.tgz#566e0bf79d1dff30a72d8bbbe9e8ecefe8d378d7"