Small patches

test/circuits/eddsamimc_test.circom

@@ -0,0 +1,3 @@
+include "../../circuits/eddsamimc.circom";
+
+component main = EdDSAMiMCVerifier();

test/eddsamimc.js

@@ -0,0 +1,98 @@
+const chai = require("chai");
+const path = require("path");
+const snarkjs = require("snarkjs");
+const compiler = require("circom");
+
+const eddsa = require("../src/eddsa.js");
+
+const assert = chai.assert;
+
+const bigInt = snarkjs.bigInt;
+
+describe("EdDSA test", function () {
+    let circuit;
+
+    this.timeout(100000);
+
+    before( async () => {
+        const cirDef = await compiler(path.join(__dirname, "circuits", "eddsamimc_test.circom"));
+
+        circuit = new snarkjs.Circuit(cirDef);
+
+        console.log("NConstrains EdDSA: " + circuit.nConstraints);
+    });
+
+    it("Sign a single number", async () => {
+        const msg = bigInt(1234);
+
+        const prvKey = Buffer.from("0001020304050607080900010203040506070809000102030405060708090001", "hex");
+
+        const pubKey = eddsa.prv2pub(prvKey);
+
+        const signature = eddsa.signMiMC(prvKey, msg);
+
+        assert(eddsa.verifyMiMC(msg, signature, pubKey));
+
+        const w = circuit.calculateWitness({
+            enabled: 1,
+            Ax: pubKey[0],
+            Ay: pubKey[1],
+            R8x: signature.R8[0],
+            R8y: signature.R8[1],
+            S: signature.S,
+            M: msg});
+
+        assert(circuit.checkWitness(w));
+    });
+
+    it("Detect Invalid signature", async () => {
+        const msg = bigInt(1234);
+
+        const prvKey = Buffer.from("0001020304050607080900010203040506070809000102030405060708090001", "hex");
+
+        const pubKey = eddsa.prv2pub(prvKey);
+
+
+        const signature = eddsa.signMiMC(prvKey, msg);
+
+        assert(eddsa.verifyMiMC(msg, signature, pubKey));
+        try {
+            const w = circuit.calculateWitness({
+                enabled: 1,
+                Ax: pubKey[0],
+                Ay: pubKey[1],
+                R8x: signature.R8[0].add(bigInt(1)),
+                R8y: signature.R8[1],
+                S: signature.S,
+                M: msg});
+            assert(false);
+        } catch(err) {
+            assert.equal(err.message, "Constraint doesn't match: 1 != 0");
+        }
+    });
+
+
+    it("Test a dissabled circuit with a bad signature", async () => {
+        const msg = bigInt(1234);
+
+        const prvKey = Buffer.from("0001020304050607080900010203040506070809000102030405060708090001", "hex");
+
+        const pubKey = eddsa.prv2pub(prvKey);
+
+
+        const signature = eddsa.signMiMC(prvKey, msg);
+
+        assert(eddsa.verifyMiMC(msg, signature, pubKey));
+
+        const w = circuit.calculateWitness({
+            enabled: 0,
+            Ax: pubKey[0],
+            Ay: pubKey[1],
+            R8x: signature.R8[0].add(bigInt(1)),
+            R8y: signature.R8[1],
+            S: signature.S,
+            M: msg});
+
+        assert(circuit.checkWitness(w));
+    });
+});

test/smtprocessor.js

@@ -22,7 +22,6 @@ async function testInsert(tree, key, value, circuit, log ) {
     const w = circuit.calculateWitness({
         fnc: [1,0],
         oldRoot: res.oldRoot,
-        newRoot: res.newRoot,
         siblings: siblings,
         oldKey: res.isOld0 ? 0 : res.oldKey,
         oldValue: res.isOld0 ? 0 : res.oldValue,
@@ -31,7 +30,7 @@ async function testInsert(tree, key, value, circuit, log ) {
         newValue: value
     }, log);
 
-    const root1 = w[circuit.getSignalIdx("main.topSwitcher.outR")];
+    const root1 = w[circuit.getSignalIdx("main.newRoot")];
     assert(circuit.checkWitness(w));
     assert(root1.equals(res.newRoot));
 }
@@ -44,7 +43,6 @@ async function testDelete(tree, key, circuit) {
     const w = circuit.calculateWitness({
         fnc: [1,1],
         oldRoot: res.oldRoot,
-        newRoot: res.newRoot,
         siblings: siblings,
         oldKey: res.isOld0 ? 0 : res.oldKey,
         oldValue: res.isOld0 ? 0 : res.oldValue,
@@ -53,7 +51,7 @@ async function testDelete(tree, key, circuit) {
         newValue: res.delValue
     });
 
-    const root1 = w[circuit.getSignalIdx("main.topSwitcher.outR")];
+    const root1 = w[circuit.getSignalIdx("main.newRoot")];
 
     assert(circuit.checkWitness(w));
     assert(root1.equals(res.newRoot));
@@ -67,7 +65,6 @@ async function testUpdate(tree, key, newValue, circuit) {
     const w = circuit.calculateWitness({
         fnc: [0,1],
         oldRoot: res.oldRoot,
-        newRoot: res.newRoot,
         siblings: siblings,
         oldKey: res.oldKey,
         oldValue: res.oldValue,
@@ -76,7 +73,7 @@ async function testUpdate(tree, key, newValue, circuit) {
         newValue: res.newValue
     });
 
-    const root1 = w[circuit.getSignalIdx("main.topSwitcher.outR")];
+    const root1 = w[circuit.getSignalIdx("main.newRoot")];
 
     assert(circuit.checkWitness(w));
     assert(root1.equals(res.newRoot));
@@ -185,7 +182,6 @@ describe("SMT test", function () {
         const w = circuit.calculateWitness({
             fnc: [0,0],
             oldRoot: 11,
-            newRoot: 22,
             siblings: siblings,
             oldKey: 33,
             oldValue: 44,
@@ -194,7 +190,11 @@ describe("SMT test", function () {
             newValue: 77
         });
 
+        const root1 = w[circuit.getSignalIdx("main.oldRoot")];
+        const root2 = w[circuit.getSignalIdx("main.newRoot")];
+
         assert(circuit.checkWitness(w));
+        assert(root1.equals(root2));
 
     });
     it("Should update an element", async () => {

test/smtverifier.js

@@ -22,6 +22,7 @@ async function testInclusion(tree, key, circuit) {
     while (siblings.length<10) siblings.push(bigInt(0));
 
     const w = circuit.calculateWitness({
+        enabled: 1,
         fnc: 0,
         root: tree.root,
         siblings: siblings,
@@ -43,6 +44,7 @@ async function testExclusion(tree, key, circuit) {
     while (siblings.length<10) siblings.push(bigInt(0));
 
     const w = circuit.calculateWitness({
+        enabled: 1,
         fnc: 1,
         root: tree.root,
         siblings: siblings,
@@ -91,5 +93,23 @@ describe("SMT test", function () {
         await testExclusion(tree, 64, circuit);
     });
 
+    it("Check not enabled accepts any thing", async () => {
+        let siblings = [];
+        for (let i=0; i<10; i++) siblings.push(i);
+
+        const w = circuit.calculateWitness({
+            enabled: 0,
+            fnc: 0,
+            root: 1,
+            siblings: siblings,
+            oldKey: 22,
+            oldValue: 33,
+            isOld0: 0,
+            key: 44,
+            value: 0
+        });
+        assert(circuit.checkWitness(w));
+    });
+
 
 });