feat: implement ECDH

.husky/commit-msg

@@ -2,3 +2,4 @@
 . "$(dirname -- "$0")/_/husky.sh"
 
 npx --no-install commitlint --edit $1
+

Nargo.toml

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

package.json

@@ -25,12 +25,23 @@
   ],
   "packageManager": "[email protected]",
   "devDependencies": {
-    "@commitlint/cli": "^18.6.1",
-    "@commitlint/config-conventional": "^18.6.2",
+    "@commitlint/cli": "^19.3.0",
+    "@commitlint/config-conventional": "^19.2.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"
+    "husky": "4",
+    "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 = "lib"
+authors = ["YashBit"]
+compiler_version = ">=0.27.0"
+
+[dependencies]

packages/ecdh/src/main.nr

@@ -0,0 +1,77 @@
+use dep::std::ec::tecurve::affine::{Curve, Point};
+
+// @@@@@@ Core ECDH Implementation
+
+/// 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);
+}
+
+// @@@@@@ UNIT TESTS
+
+// 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 that the `field_from_bytes` function correctly converts a 32-byte array of zeroes to a field element with a value of `0`.
+///
+/// This test ensures that:
+/// - The input is a 32-byte array initialized with zeroes.
+/// - The `field_from_bytes` function is called with the input and a boolean flag set to `true`.
+/// - The output is asserted to be `0`, verifying that the conversion is correct.
+#[test]
+// Define the test function for `field_from_bytes`
+fn field_from_bytes_correct() {
+    let bytes: [u8; 32] = [0; 32];
+    let field_result = field_from_bytes(bytes, true);
+    assert_eq(field_result, 0);
+}

packages/ecdh/tests/ecdh.tests.ts

@@ -0,0 +1,85 @@
+import { BarretenbergBackend } from '@noir-lang/backend_barretenberg'
+import { Noir } from '@noir-lang/noir_js'
+import { compile } from '@noir-lang/noir_wasm'
+import { ProofData } from '@noir-lang/types'
+import { expect } from 'chai'
+import { randomBytes } from 'crypto'
+import { readFileSync } from 'fs'
+import { resolve } from 'path'
+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"
+  ]
+}