feat: implement ECDH

Nargo.toml

@@ -1,2 +1,3 @@
 [workspace]
+compiler_version = ">=0.31.0"
 members = ["packages/merkle-trees"]

package.json

@@ -27,10 +27,21 @@
   "devDependencies": {
     "@commitlint/cli": "^18.6.1",
     "@commitlint/config-conventional": "^18.6.2",
+    "@types/chai": "^4",
+    "@types/mocha": "^10",
     "changelogithub": "patch:changelogithub@npm%3A0.13.3#~/.yarn/patches/changelogithub-npm-0.13.3-1783949906.patch",
     "czg": "^1.9.1",
     "dprint": "^0.46.3",
     "husky": "^9.0.11",
-    "lint-staged": "^15.2.2"
+    "lint-staged": "^15.2.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.4"
+  },
+  "dependencies": {
+    "@noir-lang/backend_barretenberg": "^0.30.0",
+    "@noir-lang/noir_js": "^0.30.0",
+    "@noir-lang/noir_wasm": "^0.32.0",
+    "chai": "^4.5.0",
+    "mocha": "^10.7.0"
   }
 }

packages/ecdh/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "ecdh"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.27.0"
+
+[dependencies]

packages/ecdh/src/main.nr

@@ -0,0 +1,68 @@
+use dep::std::ec::tecurve::affine::{Curve, Point};
+
+/// Converts a byte array to a field element.
+/// # Arguments
+/// * `bytes` - A fixed-size array of 32 bytes.
+/// * `big_endian` - A boolean indicating if the byte array is in big-endian format.
+/// # Returns
+/// A `Field` element representing the converted byte array.
+pub fn field_from_bytes(bytes: [u8; 32], big_endian: bool) -> Field {
+    let mut as_field: Field = 0;
+    let mut offset: Field = 1;
+
+    for i in 0..32 {
+        let index = if big_endian { 31 - i } else { i };
+        as_field += (bytes[index] as Field) * offset;
+        offset *= 256;
+    }
+
+    as_field
+}
+
+/// Generates a public key from a private key using the Baby JubJub curve.
+/// # Arguments
+/// * `private_key` - A field element representing the private key.
+/// * `base_point` - A point on the Baby JubJub curve used as the base point.
+/// # Returns
+/// A `Point` on the Baby JubJub curve representing the public key.
+fn generate_public_key(private_key: Field, base_point: Point) -> Point {
+    let baby_jubjub_curve = Curve::new(168700, 168696, base_point);
+    baby_jubjub_curve.mul(private_key, base_point)
+}
+
+// ECDH Circuit
+fn main(private_key1: [u8; 32], private_key2: [u8; 32]) {
+    let base_point = Point::new(
+        5299619240641551281634865583518297030282874472190772894086521144482721001553,
+        16950150798460657717958625567821834550301663161624707787222815936182638968203,
+    );
+    let private_key3 = field_from_bytes(private_key1, true);
+    let private_key4 = field_from_bytes(private_key2, true);
+    let public_key1 = generate_public_key(private_key3, base_point);
+    let public_key2 = generate_public_key(private_key4, base_point);
+    // Generate Both ECDH Shared Keys - Scalar Multiply
+    let shared_key1 = generate_public_key(private_key4, public_key1);
+    let shared_key2 = generate_public_key(private_key3, public_key2);
+    assert(shared_key1 == shared_key2);
+}
+
+// Add Individual Function Tests Here
+// Test -> Generate Public Key
+// #[test]
+// // fn public_multiply_correct() {
+// //     let base_point = Point::new(
+// //         5299619240641551281634865583518297030282874472190772894086521144482721001553,
+// //         16950150798460657717958625567821834550301663161624707787222815936182638968203,
+// //     );
+// //     let result = generate_public_key(2, base_point);
+// //     assert(result == );
+
+// // }
+
+// Test -> Field from Bytes
+// #[test]
+// fn field_from_bytes_correct() {
+//     let bytes = [0u8; 32];
+//     let result = field_from_bytes(bytes, true);
+//     assert(result == 0);
+// }

packages/ecdh/tests/ecdh.tests.ts

@@ -0,0 +1,90 @@
+import { randomBytes } from 'crypto';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { BarretenbergBackend } from '@noir-lang/backend_barretenberg';
+import { compile } from '@noir-lang/noir_wasm';
+import { Noir } from '@noir-lang/noir_js';
+import { ProofData } from '@noir-lang/types';
+import { expect } from 'chai';
+import 'mocha';
+import circuit_ecdh from '../../ecdh/target/ecdh.json';
+
+// RUN: npx mocha -r ts-node/register tests/ecdh.tests.ts
+// This will not run with yarn tests
+
+function generatePrivateKey(): Uint8Array {
+    return randomBytes(32);
+}
+
+describe("ECDH Circuit Tests", function() {
+    let noir: Noir;
+    let backend : BarretenbergBackend;
+    let correctProof: ProofData;
+    beforeEach(async () => {
+        const circuitFile = readFileSync(resolve(__dirname, '../target/ecdh.json'), 'utf-8');
+        const circuit = JSON.parse(circuitFile);
+        backend = new BarretenbergBackend(circuit);
+        noir = new Noir(circuit, backend);
+
+    });
+    it('Should generate valid proof for correct input', async function() {
+        this.timeout(20000); // Optional: Increase timeout if needed
+
+        let pk1 = generatePrivateKey();
+        let pk2 = generatePrivateKey();
+
+        // Convert Uint8Array to regular arrays
+        const input = {
+            private_key1: Array.from(pk1),
+            private_key2: Array.from(pk2)
+        };
+
+        // Generate proof
+        let correctProof;
+        try {
+            correctProof = await noir.generateProof(input);
+            console.log('Proof generated:', correctProof);
+        } catch (error) {
+            console.error('Error generating proof:', error);
+            throw error; // Ensure errors are not swallowed
+        }
+
+        // Assert that correctProof is defined and has the expected structure
+        expect(correctProof).to.not.be.undefined;
+        expect(correctProof.proof instanceof Uint8Array).to.be.true;
+    });
+
+
+});
+
+// describe("ECDH Circuit Tests", function() {
+//     let noir: Noir;
+//     let correctProof: ProofData;
+//     beforeEach(async () => {
+//         const circuitFile = readFileSync(resolve('../target/ecdh.json'), 'utf-8');
+//         const circuit = JSON.parse(circuitFile);
+//         const backend = new BarretenbergBackend(circuit);
+//         noir = new Noir(circuit, backend);   
+//     });
+//     it('Should generate valid proof for correct input', async () => {
+
+//         let pk1 = generatePrivateKey();
+//         let pk2 = generatePrivateKey();
+//         const input = {
+//             private_key1: Array.from(pk1),
+//             private_key2: Array.from(pk2)
+//         };
+
+//         // Generate proof
+//         correctProof = await noir.generateProof(input);
+//         expect(correctProof.proof).to.be.true;
+//     });
+
+//     it('Should verify valid proof for correct input', async () => {
+//         const verification = await noir.verifyProof(correctProof);
+//         expect(verification).to.be.true;
+//     });
+
+// });
+
+

tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "module": "commonjs",
+    "target": "es6",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true, // Add this line
+    "types": ["mocha", "node"]
+  },
+  "include": [
+    "./src/**/*.ts",
+    "./tests/**/*.ts"
+  ],
+  "exclude": [
+    "./dist"
+  ]
+}