starkshield 1.0.0

package/circomlib/test/comparators.js

@@ -0,0 +1,187 @@
+const chai = require("chai");
+const path = require("path");
+const F1Field = require("ffjavascript").F1Field;
+const Scalar = require("ffjavascript").Scalar;
+exports.p = Scalar.fromString("21888242871839275222246405745257275088548364400416034343698204186575808495617");
+const Fr = new F1Field(exports.p);
+
+const wasm_tester = require("circom_tester").wasm;
+
+const assert = chai.assert;
+
+describe("Comparators test", function ()  {
+
+    this.timeout(100000);
+
+    it("Should create a iszero circuit", async() => {
+        const circuit = await wasm_tester(path.join(__dirname, "circuits", "iszero.circom"));
+
+        let witness;
+        witness = await circuit.calculateWitness({ "in": 111}, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in": 0 }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+    });
+    it("Should create a isequal circuit", async() => {
+        const circuit = await wasm_tester(path.join(__dirname, "circuits", "isequal.circom"));
+
+        let witness;
+        witness = await circuit.calculateWitness({ "in": [111,222] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+
+        witness = await circuit.calculateWitness({ "in": [444,444] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+    });
+    it("Should create a comparison lessthan", async() => {
+        const circuit = await wasm_tester(path.join(__dirname, "circuits", "lessthan.circom"));
+
+        let witness;
+        witness = await circuit.calculateWitness({ "in": [333,444] }), true;
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+
+        witness = await circuit.calculateWitness({ "in":[1,1] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in": [661, 660] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in": [0, 1] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+
+        witness = await circuit.calculateWitness({ "in": [0, 444] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+
+        witness = await circuit.calculateWitness({ "in": [1, 0] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in": [555, 0] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in": [0, 0] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+    });
+    it("Should create a comparison lesseqthan", async() => {
+
+        const circuit = await wasm_tester(path.join(__dirname, "circuits", "lesseqthan.circom"));
+
+        let witness;
+        witness = await circuit.calculateWitness({ "in": [333,444] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+
+        witness = await circuit.calculateWitness({ "in":[1,1] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+
+        witness = await circuit.calculateWitness({ "in": [661, 660] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in": [0, 1] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+
+        witness = await circuit.calculateWitness({ "in": [0, 444] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+
+        witness = await circuit.calculateWitness({ "in": [1, 0] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in": [555, 0] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in": [0, 0] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+    });
+    it("Should create a comparison greaterthan", async() => {
+
+        const circuit = await wasm_tester(path.join(__dirname, "circuits", "greaterthan.circom"));
+
+        let witness;
+        witness = await circuit.calculateWitness({ "in": [333,444] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in":[1,1] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in": [661, 660] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+
+        witness = await circuit.calculateWitness({ "in": [0, 1] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in": [0, 444] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in": [1, 0] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+
+        witness = await circuit.calculateWitness({ "in": [555, 0] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+
+        witness = await circuit.calculateWitness({ "in": [0, 0] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+    });
+    it("Should create a comparison greatereqthan", async() => {
+        const circuit = await wasm_tester(path.join(__dirname, "circuits", "greatereqthan.circom"));
+
+        let witness;
+        witness = await circuit.calculateWitness({ "in": [333,444] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in":[1,1] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+
+        witness = await circuit.calculateWitness({ "in": [661, 660] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+
+        witness = await circuit.calculateWitness({ "in": [0, 1] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in": [0, 444] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(0)));
+
+        witness = await circuit.calculateWitness({ "in": [1, 0] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+
+        witness = await circuit.calculateWitness({ "in": [555, 0] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+
+        witness = await circuit.calculateWitness({ "in": [0, 0] }, true);
+        assert(Fr.eq(Fr.e(witness[0]), Fr.e(1)));
+        assert(Fr.eq(Fr.e(witness[1]), Fr.e(1)));
+    });
+});

package/circomlib/test/eddsa.js

@@ -0,0 +1,75 @@
+const chai = require("chai");
+const path = require("path");
+
+const wasm_tester = require("circom_tester").wasm;
+
+const buildEddsa = require("circomlibjs").buildEddsa;
+const buildBabyjub = require("circomlibjs").buildBabyjub;
+
+const Scalar = require("ffjavascript").Scalar;
+
+const assert = chai.assert;
+
+function print(circuit, w, s) {
+    console.log(s + ": " + w[circuit.getSignalIdx(s)]);
+}
+
+function buffer2bits(buff) {
+    const res = [];
+    for (let i=0; i<buff.length; i++) {
+        for (let j=0; j<8; j++) {
+            if ((buff[i]>>j)&1) {
+                res.push(1n);
+            } else {
+                res.push(0n);
+            }
+        }
+    }
+    return res;
+}
+
+
+describe("EdDSA test", function () {
+    let circuit;
+    let eddsa;
+    let babyJub;
+    let F;
+
+    this.timeout(100000);
+
+    before( async () => {
+        eddsa = await buildEddsa();
+        babyJub = await buildBabyjub();
+        F = babyJub.F;
+        circuit = await wasm_tester(path.join(__dirname, "circuits", "eddsa_test.circom"));
+    });
+
+
+    it("Sign a single 10 bytes from 0 to 9", async () => {
+        const msg = Buffer.from("00010203040506070809", "hex");
+
+//        const prvKey = crypto.randomBytes(32);
+
+        const prvKey = Buffer.from("0001020304050607080900010203040506070809000102030405060708090001", "hex");
+
+        const pubKey = eddsa.prv2pub(prvKey);
+
+        const pPubKey = babyJub.packPoint(pubKey);
+
+        const signature = eddsa.signPedersen(prvKey, msg);
+
+        const pSignature = eddsa.packSignature(signature);
+        const uSignature = eddsa.unpackSignature(pSignature);
+
+        assert(eddsa.verifyPedersen(msg, uSignature, pubKey));
+
+        const msgBits = buffer2bits( msg);
+        const r8Bits = buffer2bits( pSignature.slice(0, 32));
+        const sBits = buffer2bits( pSignature.slice(32, 64));
+        const aBits = buffer2bits( pPubKey);
+
+        const w = await circuit.calculateWitness({A: aBits, R8: r8Bits, S: sBits, msg: msgBits}, true);
+
+        await circuit.checkConstraints(w);
+    });
+});

package/circomlib/test/eddsamimc.js

@@ -0,0 +1,102 @@
+const chai = require("chai");
+const path = require("path");
+const wasm_tester = require("circom_tester").wasm;
+
+const buildEddsa = require("circomlibjs").buildEddsa;
+const buildBabyjub = require("circomlibjs").buildBabyjub;
+
+const assert = chai.assert;
+
+describe("EdDSA MiMC test", function () {
+    let circuit;
+    let eddsa;
+    let babyJub;
+    let F;
+
+    this.timeout(100000);
+
+    before( async () => {
+        eddsa = await buildEddsa();
+        babyJub = await buildBabyjub();
+        F = babyJub.F;
+
+        circuit = await wasm_tester(path.join(__dirname, "circuits", "eddsamimc_test.circom"));
+    });
+
+    it("Sign a single number", async () => {
+        const msg = F.e(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 = await circuit.calculateWitness({
+            enabled: 1,
+            Ax: F.toObject(pubKey[0]),
+            Ay: F.toObject(pubKey[1]),
+            R8x: F.toObject(signature.R8[0]),
+            R8y: F.toObject(signature.R8[1]),
+            S: signature.S,
+            M: F.toObject(msg)}, true);
+
+
+        await circuit.checkConstraints(w);
+
+    });
+
+    it("Detect Invalid signature", async () => {
+        const msg = F.e(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 = await circuit.calculateWitness({
+                enabled: 1,
+                Ax: F.toObject(pubKey[0]),
+                Ay: F.toObject(pubKey[1]),
+                R8x: F.toObject(F.add(signature.R8[0], F.e(1))),
+                R8y: F.toObject(signature.R8[1]),
+                S: signature.S,
+                M: F.toObject(msg)}, true);
+            assert(false);
+        } catch(err) {
+	    assert(err.message.includes("Assert Failed"));
+        }
+    });
+
+
+    it("Test a dissabled circuit with a bad signature", async () => {
+        const msg = F.e(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 = await  circuit.calculateWitness({
+            enabled: 0,
+            Ax: F.toObject(pubKey[0]),
+            Ay: F.toObject(pubKey[1]),
+            R8x: F.toObject(F.add(signature.R8[0], F.e(1))),
+            R8y: F.toObject(signature.R8[1]),
+            S: signature.S,
+            M: F.toObject(msg)}, true);
+
+        await circuit.checkConstraints(w);
+
+    });
+});

package/circomlib/test/eddsaposeidon.js

@@ -0,0 +1,103 @@
+const chai = require("chai");
+const path = require("path");
+const wasm_tester = require("circom_tester").wasm;
+
+const buildEddsa = require("circomlibjs").buildEddsa;
+const buildBabyjub = require("circomlibjs").buildBabyjub;
+
+const assert = chai.assert;
+
+describe("EdDSA Poseidon test", function () {
+    let circuit;
+    let eddsa;
+    let babyJub;
+    let F;
+
+    this.timeout(100000);
+
+    before( async () => {
+        eddsa = await buildEddsa();
+        babyJub = await buildBabyjub();
+        F = babyJub.F;
+        circuit = await wasm_tester(path.join(__dirname, "circuits", "eddsaposeidon_test.circom"));
+    });
+
+    it("Sign a single number", async () => {
+        const msg = F.e(1234);
+
+        const prvKey = Buffer.from("0001020304050607080900010203040506070809000102030405060708090001", "hex");
+
+        const pubKey = eddsa.prv2pub(prvKey);
+
+        const signature = eddsa.signPoseidon(prvKey, msg);
+
+        assert(eddsa.verifyPoseidon(msg, signature, pubKey));
+
+        const input = {
+            enabled: 1,
+            Ax: F.toObject(pubKey[0]),
+            Ay: F.toObject(pubKey[1]),
+            R8x: F.toObject(signature.R8[0]),
+            R8y: F.toObject(signature.R8[1]),
+            S: signature.S,
+            M: F.toObject(msg)
+        };
+
+        // console.log(JSON.stringify(utils.stringifyBigInts(input)));
+
+        const w = await circuit.calculateWitness(input, true);
+
+        await circuit.checkConstraints(w);
+    });
+
+    it("Detect Invalid signature", async () => {
+        const msg = F.e(1234);
+
+        const prvKey = Buffer.from("0001020304050607080900010203040506070809000102030405060708090001", "hex");
+
+        const pubKey = eddsa.prv2pub(prvKey);
+
+
+        const signature = eddsa.signPoseidon(prvKey, msg);
+
+        assert(eddsa.verifyPoseidon(msg, signature, pubKey));
+        try {
+            await circuit.calculateWitness({
+                enabled: 1,
+                Ax: F.toObject(pubKey[0]),
+                Ay: F.toObject(pubKey[1]),
+                R8x: F.toObject(F.add(signature.R8[0], F.e(1))),
+                R8y: F.toObject(signature.R8[1]),
+                S: signature.S,
+                M: F.toObject(msg)}, true);
+            assert(false);
+        } catch(err) {
+	    assert(err.message.includes("Assert Failed"));
+        }
+    });
+
+
+    it("Test a dissabled circuit with a bad signature", async () => {
+        const msg = F.e(1234);
+
+        const prvKey = Buffer.from("0001020304050607080900010203040506070809000102030405060708090001", "hex");
+
+        const pubKey = eddsa.prv2pub(prvKey);
+
+
+        const signature = eddsa.signPoseidon(prvKey, msg);
+
+        assert(eddsa.verifyPoseidon(msg, signature, pubKey));
+
+        const w = await circuit.calculateWitness({
+            enabled: 0,
+            Ax: F.toObject(pubKey[0]),
+            Ay: F.toObject(pubKey[1]),
+            R8x: F.toObject(F.add(signature.R8[0], F.e(1))),
+            R8y: F.toObject(signature.R8[1]),
+            S: signature.S,
+            M: F.toObject(msg)}, true);
+
+        await circuit.checkConstraints(w);
+    });
+});

package/circomlib/test/escalarmul.js

@@ -0,0 +1,121 @@
+const chai = require("chai");
+const path = require("path");
+const wasm_tester = require("circom_tester").wasm;
+const buildBabyjub = require("circomlibjs").buildBabyjub;
+
+const Scalar = require("ffjavascript").Scalar;
+
+const assert = chai.assert;
+
+function print(circuit, w, s) {
+    console.log(s + ": " + w[circuit.getSignalIdx(s)]);
+}
+
+describe("Exponentioation test", function () {
+    let babyJub;
+    let Fr;
+    this.timeout(100000);
+
+    before( async () => {
+        babyJub = await buildBabyjub();
+        Fr = babyJub.F;
+    });
+
+    it("Should generate the Exponentiation table in k=0", async () => {
+
+        const circuit = await wasm_tester(path.join(__dirname, "circuits", "escalarmulw4table_test.circom"));
+
+        const w = await circuit.calculateWitness({in: 1});
+
+        await circuit.checkConstraints(w);
+
+        let g = [
+            Fr.e("5299619240641551281634865583518297030282874472190772894086521144482721001553"),
+            Fr.e("16950150798460657717958625567821834550301663161624707787222815936182638968203")
+        ];
+
+        let dbl= [Fr.e("0"), Fr.e("1")];
+
+        const expectedOut = [];
+
+        for (let i=0; i<16; i++) {
+
+            expectedOut.push([Fr.toObject(dbl[0]), Fr.toObject(dbl[1])]);
+            dbl = babyJub.addPoint(dbl,g);
+        }
+
+        await circuit.assertOut(w, {out: expectedOut});
+
+    });
+
+    it("Should generate the Exponentiation table in k=3", async () => {
+
+        const circuit = await wasm_tester(path.join(__dirname, "circuits", "escalarmulw4table_test3.circom"));
+
+        const w = await circuit.calculateWitness({in: 1});
+
+        await circuit.checkConstraints(w);
+
+        let g = [
+            Fr.e("5299619240641551281634865583518297030282874472190772894086521144482721001553"),
+            Fr.e("16950150798460657717958625567821834550301663161624707787222815936182638968203")
+        ];
+
+        for (let i=0; i<12;i++) {
+            g = babyJub.addPoint(g,g);
+        }
+
+        let dbl= [Fr.e("0"), Fr.e("1")];
+
+        const expectedOut = [];
+
+        for (let i=0; i<16; i++) {
+            expectedOut.push([Fr.toObject(dbl[0]), Fr.toObject(dbl[1])]);
+
+            dbl = babyJub.addPoint(dbl,g);
+        }
+
+        await circuit.assertOut(w, {out: expectedOut});
+
+    });
+
+    it("Should exponentiate g^31", async () => {
+
+        const circuit = await wasm_tester(path.join(__dirname, "circuits", "escalarmul_test.circom"));
+
+        const w = await circuit.calculateWitness({"in": 31});
+
+        await circuit.checkConstraints(w);
+
+        let g = [
+            Fr.e("5299619240641551281634865583518297030282874472190772894086521144482721001553"),
+            Fr.e("16950150798460657717958625567821834550301663161624707787222815936182638968203")
+        ];
+
+        let c = [Fr.e(0), Fr.e(1)];
+
+        for (let i=0; i<31;i++) {
+            c = babyJub.addPoint(c,g);
+        }
+
+        await circuit.assertOut(w, {out: [Fr.toObject(c[0]), Fr.toObject(c[1])] });
+
+        const w2 = await circuit.calculateWitness({"in": Scalar.add(Scalar.shl(Scalar.e(1), 252),Scalar.e(1))});
+
+        c = [g[0], g[1]];
+        for (let i=0; i<252;i++) {
+            c = babyJub.addPoint(c,c);
+        }
+        c = babyJub.addPoint(c,g);
+
+        await circuit.assertOut(w2, {out: [Fr.toObject(c[0]), Fr.toObject(c[1])] });
+
+    }).timeout(10000000);
+
+    it("Number of constrains for 256 bits", async () => {
+
+        const circuit = await wasm_tester(path.join(__dirname, "circuits", "escalarmul_test_min.circom"));
+
+    }).timeout(10000000);
+
+});

package/circomlib/test/escalarmulany.js

@@ -0,0 +1,51 @@
+const chai = require("chai");
+const path = require("path");
+const wasm_tester = require("circom_tester").wasm;
+
+const F1Field = require("ffjavascript").F1Field;
+const Scalar = require("ffjavascript").Scalar;
+exports.p = Scalar.fromString("21888242871839275222246405745257275088548364400416034343698204186575808495617");
+const Fr = new F1Field(exports.p);
+
+function print(circuit, w, s) {
+    console.log(s + ": " + w[circuit.getSignalIdx(s)]);
+}
+
+describe("Escalarmul test", function () {
+    let circuitEMulAny;
+
+    this.timeout(100000);
+
+    let g;
+
+    before( async() => {
+        circuitEMulAny = await wasm_tester(path.join(__dirname, "circuits", "escalarmulany_test.circom"));
+        g = [
+                Fr.e("5299619240641551281634865583518297030282874472190772894086521144482721001553"),
+                Fr.e("16950150798460657717958625567821834550301663161624707787222815936182638968203")
+            ]
+    });
+
+    it("Should generate Same escalar mul", async () => {
+
+        const w = await circuitEMulAny.calculateWitness({"e": 1, "p": g});
+
+        await circuitEMulAny.checkConstraints(w);
+
+        await circuitEMulAny.assertOut(w, {out: g}, true);
+
+    });
+
+    it("If multiply by order should return 0", async () => {
+
+        const r = Fr.e("2736030358979909402780800718157159386076813972158567259200215660948447373041");
+        const w = await circuitEMulAny.calculateWitness({"e": r, "p": g});
+
+        await circuitEMulAny.checkConstraints(w);
+
+        await circuitEMulAny.assertOut(w, {out: [0,1]}, true);
+
+    });
+
+});
+