Merge pull request #20 from bellesmarta/master

Updated README files
0.0.18
2019-09-23 14:58:24 +02:00 · 2019-09-17 07:57:45 +02:00 · 2019-09-17 08:55:22 +03:00 · 2019-09-17 08:53:02 +03:00 · 2019-09-15 10:52:50 +02:00 · 2019-09-15 10:52:18 +02:00
39 changed files with 1805 additions and 11888 deletions
--- a/README.md
+++ b/README.md
@@ -1,4 +1,17 @@
-# cirpedersen
+# CircomLib

-Pedersen Hash and Exponentiation circuits using Baby Jub Curve in circom language
+## Description

+- This repository contains a library of circuit templates. 
+- All files are copyrighted under 2018 0KIMS association and part of the free software [circom](https://github.com/iden3/circom) (Zero Knowledge Circuit Compiler). 
+
+## Organisation
+
+This respository contains 5 folders:
+- `circuits`: it contains the implementation of different cryptographic primitives in circom language.
+- `calcpedersenbases`: set of functions in JavaScript used to find a set of points in [Baby Jubjub](https://github.com/barryWhiteHat/baby_jubjub) elliptic curve that serve as basis for the [Pedersen Hash](https://github.com/zcash/zcash/issues/2234).
+- `doc`: it contains some circuit schemes in ASCII (must be opened with Monodraw, an ASCII art editor for Mac).
+- `src`: it contains similar implementation of circuits in JavaScript.
+- `test`: tests.
+
+A description of the specific circuit templates for the `circuit` folder will be soon updated.
--- a/calcpedersenbases/calcpedersenbases.js
+++ b/calcpedersenbases/calcpedersenbases.js
@@ -64,8 +64,8 @@ function generatePoint(S) {


 const g = [
-    bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
-    bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475")];
+    bigInt("5299619240641551281634865583518297030282874472190772894086521144482721001553"),
+    bigInt("16950150798460657717958625567821834550301663161624707787222815936182638968203")];

 // Sanity check
 if (!babyJub.inCurve(g)) {
--- a/circuits/README.md
+++ b/circuits/README.md
@@ -1,3 +1,19 @@
+# CircomLib/Circuits
+
+## Description
+
+- This folder contains circuit templates for standard operations and many cryptographic primitives.
+- Below you can find specifications of each function. In the representation of elements, there are three tyes:
+    - Binary
+    - String
+    - Field element (the field is specified in each case. We consider 2 possible fields: Fp and Fr, where p... and r... .)
+
+## Table of Contents
+
+[TOC]
+
+## Jordi
+
 * compconstant - Returns 1 if `in` (expanded to binary array) > `ct`
 * aliascheck - check if `in` (expanded to binary array) oveflowed its 254 bits (<= -1)
 * babyjub - twisted Edwards curve 168700.x^2 + y^2 = 1 + 168696.x^2.y^2
@@ -11,4 +27,804 @@
  * zcash/zcash#2233
 * smt - Sparse Merkle Tree
  * https://ethresear.ch/t/optimizing-sparse-merkle-trees/3751
-* montgomery https://en.wikipedia.org/wiki/Montgomery_curve
+* montgomery https://en.wikipedia.org/wiki/Montgomery_curve
+
+## Circuits
+
+### sha256
+
+Folder containing the implementation of sha256 hash circuit.
+
+### smt
+
+Folder containing the circuit implementation of Sparse Merkle Trees.
+
+### aliascheck
+
+- `AliasCheck()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+    
+### babyjub
+
+Arithmetic on [Baby Jubjub elliptic curve](https://github.com/barryWhiteHat/baby_jubjub) in twisted Edwards form. (TODO: Expose here the characteristics of the curve?)
+
+
+- `BabyAdd()`
+
+    - DESCRIPTION
+    
+      It adds two points on the Baby Jubjub curve. More specifically, given two points P1 = (`x1`, `y1`) and P2 = (`x2`, `y2`) it returns a point P3 = (`xout`, `yout`)  such that
+
+        (`xout`, `yout`) =  (`x1`,`y1`) + (`x2`,`y2`) 
+             = ((`x1y2`+`y1x2`)/(1+`dx1x2y1y2`)),(`y1y2`-`ax1x2`)/(1-`dx1x2y1y2`))
+    
+    - SCHEMA
+       ```
+                                        var a     var d
+                                          |         |
+                                          |         |
+                                    ______v_________v_______     
+                   input x1 ---->  |                        |
+                   input y1 ---->  |        BabyAdd()       | ----> output xout
+                   input x2 ---->  |                        | ----> output yout
+                   input y2 ---->  |________________________|     
+       ```
+
+    - INPUTS
+
+      | Input         | Representation | Description         |                                             |
+      | ------------- | -------------  | -------------       | -------------                               |
+      | `x1`          | Bigint         | Field element of Fp | First coordinate of a point (x1, y1) on E.  |
+      | `y1`          | Bigint         | Field element of Fp | Second coordinate of a point (x1, y1) on E. |
+      | `x2`          | Bigint         | Field element of Fp | First coordinate of a point (x2, y2) on E.  |
+      | `y2`          | Bigint         | Field element of Fp | Second coordinate of a point (x2, y2) on E. |
+   
+      Requirement: at least `x1`!=`x2` or `y1`!=`y2`.
+
+    - OUTPUT
+        
+      | Input         | Representation | Description         |                                             |
+      | ------------- | -------------  | -------------       | -------------                               |
+      | `xout`          | Bigint         | Field element of Fp | First coordinate of the addition point (xout, yout) = (x1, y1) + (x2, y2).  |
+      | `yout`          | Bigint         | Field element of Fp | Second coordinate of the addition point (xout, yout) = (x1, y1) + (x2, y2). |
+        
+    - BENCHMARKS (constraints)
+
+    - EXAMPLE
+
+- `BabyDbl()`
+    - DESCRIPTION : doubles a point (`xout`,`yout`) = 2*(`x`,`y`).
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `BabyCheck()`
+
+    - DESCRIPTION : checks if a given point is in the curve. 
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `BabyPbk()`
+
+    - DESCRIPTION: : given a private key, it returns the associated public key.
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+
+### binsub
+
+- `BinSub(n)`    
+
+    - DESCRIPTION: binary substraction.
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### binsum
+
+- `nbits(a)`
+
+    - DESCRIPTION : binary sum. 
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `BinSum(n, ops)`
+
+    - DESCRIPTION 
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### bitify
+
+- `Num2Bits()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Num2Bits_strict()`
+
+    - DESCRIPTION 
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Bits2Num()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Bits2Num_strict()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Num2BitsNeg()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### comparators
+
+- `IsZero() `
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `IsEqual()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `ForceEqualIfEnabled()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `LessThan()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `GreaterThan()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `GreaterEqThan()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### compconstant 
+
+- `CompConstant(ct)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### eddsa
+
+Edwards Digital Signature Algorithm in Baby Jubjbub (link a eddsa)
+
+- `EdDSAVerifier(n)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### eddsamimc
+
+- `EdDSAMiMCVerifier()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### eddsamimcsponge
+
+- `EdDSAMiMCSpongeVerifier()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### eddsaposeidon
+
+- `EdDSAPoseidonVerifier()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### escalarmul
+
+- `EscalarMulWindow(base, k)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `EscalarMul(n, base)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### escalarmulany
+
+- `Multiplexor2()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `BitElementMulAny()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `SegmentMulAny(n)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `EscalarMulAny(n)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### escalarmulfix
+
+- `WindowMulFix()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `SegmentMulFix(nWindows)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `EscalarMulFix(n, BASE)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### escalarmulw4table
+
+- `pointAdd`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `EscalarMulW4Table`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### gates
+
+- `XOR`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `AND`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `OR`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `NOT`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `NAND`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `NOR`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `MultiAND`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### mimc
+
+Implementation of MiMC-7 hash in Fp being...  (link to description of the hash)
+
+- `MiMC7(nrounds)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `MultiMiMC7(nInputs, nRounds)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### mimcsponge
+
+- `MiMCSponge(nInputs, nRounds, nOutputs)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `MiMCFeistel(nrounds)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### montgomery
+
+- `Edwards2Montgomery()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Montgomery2Edwards()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `MontgomeryAdd()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `MontgomeryDouble()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### multiplexer
+
+- `log2(a)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `EscalarProduct(w)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Decoder(w)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Multiplexer(wIn, nIn)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### mux1
+
+- `MultiMux1(n)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Mux1()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### mux2
+
+- `MultiMux2(n)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Mux2()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### mux3
+
+- `MultiMux3(n)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Mux3()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### mux4
+
+- `MultiMux4(n)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Mux4()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### pedersen_old
+
+Old version of the Pedersen hash (do not use any 
+more?).
+
+### pedersen
+
+- `Window4()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Segment(nWindows)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Pedersen(n)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### pointbits  
+
+- `sqrt(n)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Bits2Point()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Bits2Point_Strict()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Point2Bits`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Point2Bits_Strict`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### poseidon
+
+Implementation of Poseidon hash function (LINK)
+
+- `Sigma()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Ark(t, C)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Mix(t, M)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+- `Poseidon(nInputs, t, nRoundsF, nRoundsP)`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### sign
+
+- `Sign()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
+
+### switcher
+
+- `Switcher()`
+
+    - DESCRIPTION
+    - SCHEMA
+    - INPUT
+    - OUTPUT
+    - BENCHMARKS
+    - EXAMPLE
--- a/circuits/babyjub.circom
+++ b/circuits/babyjub.circom
@@ -88,8 +88,8 @@ template BabyPbk() {
    signal         output Ay;

    var BASE8 = [
-        17777552123799933955779906779655732241715742912184938656739573121738514868268,
-        2626589144620713026669568689430873010625803728049924121243784502389097019475
+        5299619240641551281634865583518297030282874472190772894086521144482721001553,
+        16950150798460657717958625567821834550301663161624707787222815936182638968203
    ];

    component pvkBits = Num2Bits(253);
--- a/circuits/eddsa.circom
+++ b/circuits/eddsa.circom
@@ -123,8 +123,8 @@ template EdDSAVerifier(n) {
 // Calculate left side of equation left = S*B8

    var BASE8 = [
-        17777552123799933955779906779655732241715742912184938656739573121738514868268,
-        2626589144620713026669568689430873010625803728049924121243784502389097019475
+        5299619240641551281634865583518297030282874472190772894086521144482721001553,
+        16950150798460657717958625567821834550301663161624707787222815936182638968203
    ];
    component mulFix = EscalarMulFix(256, BASE8);
    for (i=0; i<256; i++) {
--- a/circuits/eddsamimc.circom
+++ b/circuits/eddsamimc.circom
@@ -101,8 +101,8 @@ template EdDSAMiMCVerifier() {
 // Calculate left side of equation left = S*B8

    var BASE8 = [
-        17777552123799933955779906779655732241715742912184938656739573121738514868268,
-        2626589144620713026669568689430873010625803728049924121243784502389097019475
+        5299619240641551281634865583518297030282874472190772894086521144482721001553,
+        16950150798460657717958625567821834550301663161624707787222815936182638968203
    ];
    component mulFix = EscalarMulFix(253, BASE8);
    for (i=0; i<253; i++) {
--- a/circuits/eddsamimcsponge.circom
+++ b/circuits/eddsamimcsponge.circom
@@ -101,8 +101,8 @@ template EdDSAMiMCSpongeVerifier() {
 // Calculate left side of equation left = S*B8

    var BASE8 = [
-        17777552123799933955779906779655732241715742912184938656739573121738514868268,
-        2626589144620713026669568689430873010625803728049924121243784502389097019475
+        5299619240641551281634865583518297030282874472190772894086521144482721001553,
+        16950150798460657717958625567821834550301663161624707787222815936182638968203
    ];
    component mulFix = EscalarMulFix(253, BASE8);
    for (i=0; i<253; i++) {
--- a/circuits/eddsaposeidon.circom
+++ b/circuits/eddsaposeidon.circom
@@ -47,7 +47,7 @@ template EdDSAPoseidonVerifier() {
        snum2bits.out[i] ==> compConstant.in[i];
    }
    compConstant.in[253] <== 0;
-    compConstant.out === 0;
+    compConstant.out*enabled === 0;

 // Calculate the h = H(R,A, msg)

@@ -79,7 +79,7 @@ template EdDSAPoseidonVerifier() {
    // We check that A is not zero.
    component isZero = IsZero();
    isZero.in <== dbl3.x;
-    isZero.out === 0;
+    isZero.out*enabled === 0;

    component mulAny = EscalarMulAny(254);
    for (i=0; i<254; i++) {
@@ -100,8 +100,8 @@ template EdDSAPoseidonVerifier() {
 // Calculate left side of equation left = S*B8

    var BASE8 = [
-        17777552123799933955779906779655732241715742912184938656739573121738514868268,
-        2626589144620713026669568689430873010625803728049924121243784502389097019475
+        5299619240641551281634865583518297030282874472190772894086521144482721001553,
+        16950150798460657717958625567821834550301663161624707787222815936182638968203
    ];
    component mulFix = EscalarMulFix(253, BASE8);
    for (i=0; i<253; i++) {
--- a/circuits/escalarmulany.circom
+++ b/circuits/escalarmulany.circom
@@ -19,6 +19,7 @@

 include "montgomery.circom";
 include "babyjub.circom";
+include "comparators.circom";

 template Multiplexor2() {
    signal input sel;
@@ -138,6 +139,8 @@ template EscalarMulAny(n) {
    component doublers[nsegments-1];
    component m2e[nsegments-1];
    component adders[nsegments-1];
+    component zeropoint = IsZero();
+    zeropoint.in <== p[0];

    var s;
    var i;
@@ -154,8 +157,9 @@ template EscalarMulAny(n) {
        }

        if (s==0) {
-            p[0] ==> segments[s].p[0];
-            p[1] ==> segments[s].p[1];
+            // force G8 point if input point is zero
+            segments[s].p[0] <== p[0] + (5299619240641551281634865583518297030282874472190772894086521144482721001553 - p[0])*zeropoint.out;
+            segments[s].p[1] <== p[1] + (16950150798460657717958625567821834550301663161624707787222815936182638968203 - p[1])*zeropoint.out;
        } else {
            doublers[s-1] = MontgomeryDouble();
            m2e[s-1] = Montgomery2Edwards();
@@ -183,10 +187,10 @@ template EscalarMulAny(n) {
    }

    if (nsegments == 1) {
-        segments[0].out[0] ==> out[0];
-        segments[0].out[1] ==> out[1];
+        segments[0].out[0]*(1-zeropoint.out) ==> out[0];
+        segments[0].out[1]+(1-segments[0].out[1])*zeropoint.out ==> out[1];
    } else {
-        adders[nsegments-2].xout ==> out[0];
-        adders[nsegments-2].yout ==> out[1];
+        adders[nsegments-2].xout*(1-zeropoint.out) ==> out[0];
+        adders[nsegments-2].yout+(1-adders[nsegments-2].yout)*zeropoint.out ==> out[1];
    }
 }
--- a/circuits/escalarmulfix.circom
+++ b/circuits/escalarmulfix.circom
@@ -28,6 +28,22 @@ include "babyjub.circom";

    The result should be compensated.
 */
+
+/*
+
+    The scalar is s = a0 + a1*2^3 + a2*2^6 + ...... + a81*2^243
+    First We calculate Q = B + 2^3*B + 2^6*B + ......... + 2^246*B
+
+    Then we calculate S1 = 2*2^246*B + (1 + a0)*B + (2^3 + a1)*B + .....+ (2^243 + a81)*B
+
+    And Finaly we compute the result: RES = SQ - Q
+
+    As you can see the input of the adders cannot be equal nor zero, except for the last
+    substraction that it's done in montgomery.
+
+    A good way to see it is that the accumulator input of the adder >= 2^247*B and the other input
+    is the output of the windows that it's going to be <= 2^246*B
+ */
 template WindowMulFix() {
    signal input in[3];
    signal input base[2];
@@ -140,54 +156,60 @@ template SegmentMulFix(nWindows) {
    e2m.in[1] <== base[1];

    component windows[nWindows];
-    component adders[nWindows-1];
-    component cadders[nWindows-1];
+    component adders[nWindows];
+    component cadders[nWindows];
+
+    // In the last step we add an extra doubler so that numbers do not match.
+    component dblLast = MontgomeryDouble();
+
    for (i=0; i<nWindows; i++) {
        windows[i] = WindowMulFix();
+        cadders[i] = MontgomeryAdd();
        if (i==0) {
            windows[i].base[0] <== e2m.out[0];
            windows[i].base[1] <== e2m.out[1];
+            cadders[i].in1[0] <== e2m.out[0];
+            cadders[i].in1[1] <== e2m.out[1];
        } else {
            windows[i].base[0] <== windows[i-1].out8[0];
            windows[i].base[1] <== windows[i-1].out8[1];
-
-            adders[i-1] = MontgomeryAdd();
-            cadders[i-1] = MontgomeryAdd();
-            if (i==1) {
-                adders[i-1].in1[0] <== windows[0].out[0];
-                adders[i-1].in1[1] <== windows[0].out[1];
-                cadders[i-1].in1[0] <== e2m.out[0];
-                cadders[i-1].in1[1] <== e2m.out[1];
-            } else {
-                adders[i-1].in1[0] <== adders[i-2].out[0];
-                adders[i-1].in1[1] <== adders[i-2].out[1];
-                cadders[i-1].in1[0] <== cadders[i-2].out[0];
-                cadders[i-1].in1[1] <== cadders[i-2].out[1];
-            }
-            adders[i-1].in2[0] <== windows[i].out[0];
-            adders[i-1].in2[1] <== windows[i].out[1];
-            cadders[i-1].in2[0] <== windows[i-1].out8[0];
-            cadders[i-1].in2[1] <== windows[i-1].out8[1];
+            cadders[i].in1[0] <== cadders[i-1].out[0];
+            cadders[i].in1[1] <== cadders[i-1].out[1];
+        }
+        if (i<nWindows-1) {
+            cadders[i].in2[0] <== windows[i].out8[0];
+            cadders[i].in2[1] <== windows[i].out8[1];
+        } else {
+            dblLast.in[0] <== windows[i].out8[0];
+            dblLast.in[1] <== windows[i].out8[1];
+            cadders[i].in2[0] <== dblLast.out[0];
+            cadders[i].in2[1] <== dblLast.out[1];
        }
        for (j=0; j<3; j++) {
            windows[i].in[j] <== e[3*i+j];
        }
    }

+    for (i=0; i<nWindows; i++) {
+        adders[i] = MontgomeryAdd();
+        if (i==0) {
+            adders[i].in1[0] <== dblLast.out[0];
+            adders[i].in1[1] <== dblLast.out[1];
+        } else {
+            adders[i].in1[0] <== adders[i-1].out[0];
+            adders[i].in1[1] <== adders[i-1].out[1];
+        }
+        adders[i].in2[0] <== windows[i].out[0];
+        adders[i].in2[1] <== windows[i].out[1];
+    }
+
    component m2e = Montgomery2Edwards();
    component cm2e = Montgomery2Edwards();

-    if (nWindows > 1) {
-        m2e.in[0] <== adders[nWindows-2].out[0];
-        m2e.in[1] <== adders[nWindows-2].out[1];
-        cm2e.in[0] <== cadders[nWindows-2].out[0];
-        cm2e.in[1] <== cadders[nWindows-2].out[1];
-    } else {
-        m2e.in[0] <== windows[0].out[0];
-        m2e.in[1] <== windows[0].out[1];
-        cm2e.in[0] <== e2m.out[0];
-        cm2e.in[1] <== e2m.out[1];
-    }
+    m2e.in[0] <== adders[nWindows-1].out[0];
+    m2e.in[1] <== adders[nWindows-1].out[1];
+    cm2e.in[0] <== cadders[nWindows-1].out[0];
+    cm2e.in[1] <== cadders[nWindows-1].out[1];

    component cAdd = BabyAdd();
    cAdd.x1 <== m2e.out[0];
@@ -195,7 +217,6 @@ template SegmentMulFix(nWindows) {
    cAdd.x2 <== -cm2e.out[0];
    cAdd.y2 <== cm2e.out[1];

-
    cAdd.xout ==> out[0];
    cAdd.yout ==> out[1];

@@ -214,7 +235,7 @@ template EscalarMulFix(n, BASE) {
    signal input e[n];              // Input in binary format
    signal output out[2];           // Point (Twisted format)

-    var nsegments = (n-1)\249 +1;
+    var nsegments = (n-1)\246 +1;       // 249 probably would work. But I'm not sure and for security I keep 246
    var nlastsegment = n - (nsegments-1)*249;

    component segments[nsegments];
@@ -225,7 +246,7 @@ template EscalarMulFix(n, BASE) {
    var s;
    var i;
    var nseg;
-    var nWindows
+    var nWindows;

    for (s=0; s<nsegments; s++) {

--- a/circuits/mimcsponge.circom
+++ b/circuits/mimcsponge.circom
@@ -21,7 +21,7 @@ template MiMCSponge(nInputs, nRounds, nOutputs) {
    }
  }

-  outs[0] = S[nInputs - 1].xL_out;
+  outs[0] <== S[nInputs - 1].xL_out;

  for (var i = 0; i < nOutputs - 1; i++) {
    S[nInputs + i] = MiMCFeistel(nRounds);
--- a/circuits/poseidon.circom
+++ b/circuits/poseidon.circom
@@ -41,119 +41,120 @@ template Mix(t, M) {
 template Poseidon(nInputs, t, nRoundsF, nRoundsP) {

    var C = [
-        1354025385229961744769229343273868518314335569873439558835166239576773343708,
-        14378844218625331047742339561309620904043097700980163591187076404481144585564,
-        19370813333785034372560258124535206525278124675105547990205946542330734467847,
-        19339919977375282793227987561727366424934767905100680591050582380667086628202,
-        8422275364316831706903446151602338206948363474119622730702497535467809432414,
-        7433947928146794739292515659214608949964639549664630885486968546133071892830,
-        20753350951496713264979200428833003140825588922450200809553577914404143341040,
-        21437018888080559864996889038552602698883513894753499324572098534369350747880,
-        6815447461573214810645016226370803316854141900901895816072622961504507953749,
-        11746901014017411226283657362310634990885933032228701131899561585228216986615,
-        13428722985713722660261823704226749286675766756093697029778643398137361221114,
-        10894749142018158588533110743373157663019829222177356873395009880383491602356,
-        13720066349319517776784660327982201297420012713976744204318378121767771862484,
-        4665971664531891307640113589671067488692829783046247264698659233443166028412,
-        5364541878673041196937884015923978656299860601766012213141306792903990539664,
-        1747411112078838632103476037026417344408680910500491241306123941341644055714,
-        1835035066071759522152578007305026433897204459772540871869487151042238374039,
-        21055637025200882290106914253232617255445210101773537879323245961051751183138,
-        19215142378199333594641095299020637309879189505235993967243075316794127016728,
-        5264915734761449905856538116909638235466879053604660991987579054616980096262,
-        10045917614023673044141331581538797960977704806582630277050701175565262856382,
-        7789533631025313780520004400945166898631872921910178131342071973345076732672,
-        19972498130123740615813398456152565371201412297339860820234719562997192378694,
-        14216077977931104808041453382683965630500368477063603536695472115075869912121,
-        2555981910568472028679439033700033287358333564454149464965229699417319912931,
-        11735111941739477522347883122573591136355121750109794306409399099068977659499,
-        16957890207070910233505303498878270130436461648242792271152604513138986611609,
-        358520143235124107055243451716507147499373646513864848163778795927281509793,
-        6389190271835493841487214043252929516390267871881261173336690351147926750010,
-        12939611907106878137030264379019786496625916664142697309441198804098015086205,
-        456696638239570875759108333278090964360604015255503302016190396687826618227,
-        20569764931577491771523222445135914903999292206008007769649255123342890660989,
-        3341317247281280728261320226215152668194921091152837358683334635401182164637,
-        11821224368797169892747612081573458772211068320533296007836648033607696236615,
-        2185176387193659864764608304330502180888068591409305411859725028056771843945,
-        17161758741114551704796078639849789476380746803787101178795737276111464575519,
-        11889888355183092530573415929875444766831739308191993115663429638848547668798,
-        19503084309842095729857399025417533485089330284851492085544757107759925099089,
-        20280152151768521735424910115623976684589382048161526796204268413029416266256,
-        17607351334578006856860845064970248988416315904757246948622629528628773644114,
-        20769468546336672951384440602623018830493119282829911435465737079851020547355,
-        1546429204704408801701093430086546742691081844046642451323347737810191940866,
-        11200569249561318620053458114013886527484999499632128671282997438827107108229,
-        20198213289062010915914579158889968647687156198219713083074315178786791524034,
-        12911209060630719799682705729835581341676468319742562559036843993017369855977,
-        18925188847138989248835676768641716482476141553833902070405850166412140133887,
-        20376466983584239909415025821007315251422803039634139484663713769887712746966,
-        5250536177612235431141386983455571232984126980327432803966957255414592397060,
-        344847263093423485167610155050688875010578621416939967999896518937961396680,
-        19870333728541576497318505013425518731999037041271340888970559590767369935385,
-        20604512495859902382577228682521142736989261702707317046150335692410020156250,
-        18293964088694556689667514948280720605277532123251572448395882397578643211622,
-        21211253784206079547762943120791531326787601501123474236198383850531142559075,
-        17247914781304154940895909185506123510423535554247372833321968000513811053190,
-        16432189025237084563810000088202867449333673799705533820685782829379758927490,
-        7204783063529242442830743239980168374343946353418800547956909848044774363774,
-        2108268032972510691814120801033692084861951866306906253604497017452204030001,
-        13483247063999686990721729188827693318708500027762095503921527692630827328070,
-        18194665574704709729868916970580318177272365766028499528691737819467051567534,
-        9275639092314761435364537152118796424056864859607619908791935597976913759411,
-        12700165678727983685032332532042155014245610964583614362270316386368455898604,
-        19127554193875137546212792134421555344854604853165878912238751527694270097310,
-        16817455471920423226570476063669349525676437756352144502692679769377074040335,
-        17331185397945904160678487303485263376032543419657328137924881433628614769955,
-        11605569208043267134285833752214422326246425655661043119023566733685555142420
+        14397397413755236225575615486459253198602422701513067526754101844196324375522,
+        10405129301473404666785234951972711717481302463898292859783056520670200613128,
+        5179144822360023508491245509308555580251733042407187134628755730783052214509,
+        9132640374240188374542843306219594180154739721841249568925550236430986592615,
+        20360807315276763881209958738450444293273549928693737723235350358403012458514,
+        17933600965499023212689924809448543050840131883187652471064418452962948061619,
+        3636213416533737411392076250708419981662897009810345015164671602334517041153,
+        2008540005368330234524962342006691994500273283000229509835662097352946198608,
+        16018407964853379535338740313053768402596521780991140819786560130595652651567,
+        20653139667070586705378398435856186172195806027708437373983929336015162186471,
+        17887713874711369695406927657694993484804203950786446055999405564652412116765,
+        4852706232225925756777361208698488277369799648067343227630786518486608711772,
+        8969172011633935669771678412400911310465619639756845342775631896478908389850,
+        20570199545627577691240476121888846460936245025392381957866134167601058684375,
+        16442329894745639881165035015179028112772410105963688121820543219662832524136,
+        20060625627350485876280451423010593928172611031611836167979515653463693899374,
+        16637282689940520290130302519163090147511023430395200895953984829546679599107,
+        15599196921909732993082127725908821049411366914683565306060493533569088698214,
+        16894591341213863947423904025624185991098788054337051624251730868231322135455,
+        1197934381747032348421303489683932612752526046745577259575778515005162320212,
+        6172482022646932735745595886795230725225293469762393889050804649558459236626,
+        21004037394166516054140386756510609698837211370585899203851827276330669555417,
+        15262034989144652068456967541137853724140836132717012646544737680069032573006,
+        15017690682054366744270630371095785995296470601172793770224691982518041139766,
+        15159744167842240513848638419303545693472533086570469712794583342699782519832,
+        11178069035565459212220861899558526502477231302924961773582350246646450941231,
+        21154888769130549957415912997229564077486639529994598560737238811887296922114,
+        20162517328110570500010831422938033120419484532231241180224283481905744633719,
+        2777362604871784250419758188173029886707024739806641263170345377816177052018,
+        15732290486829619144634131656503993123618032247178179298922551820261215487562,
+        6024433414579583476444635447152826813568595303270846875177844482142230009826,
+        17677827682004946431939402157761289497221048154630238117709539216286149983245,
+        10716307389353583413755237303156291454109852751296156900963208377067748518748,
+        14925386988604173087143546225719076187055229908444910452781922028996524347508,
+        8940878636401797005293482068100797531020505636124892198091491586778667442523,
+        18911747154199663060505302806894425160044925686870165583944475880789706164410,
+        8821532432394939099312235292271438180996556457308429936910969094255825456935,
+        20632576502437623790366878538516326728436616723089049415538037018093616927643,
+        71447649211767888770311304010816315780740050029903404046389165015534756512,
+        2781996465394730190470582631099299305677291329609718650018200531245670229393,
+        12441376330954323535872906380510501637773629931719508864016287320488688345525,
+        2558302139544901035700544058046419714227464650146159803703499681139469546006,
+        10087036781939179132584550273563255199577525914374285705149349445480649057058,
+        4267692623754666261749551533667592242661271409704769363166965280715887854739,
+        4945579503584457514844595640661884835097077318604083061152997449742124905548,
+        17742335354489274412669987990603079185096280484072783973732137326144230832311,
+        6266270088302506215402996795500854910256503071464802875821837403486057988208,
+        2716062168542520412498610856550519519760063668165561277991771577403400784706,
+        19118392018538203167410421493487769944462015419023083813301166096764262134232,
+        9386595745626044000666050847309903206827901310677406022353307960932745699524,
+        9121640807890366356465620448383131419933298563527245687958865317869840082266,
+        3078975275808111706229899605611544294904276390490742680006005661017864583210,
+        7157404299437167354719786626667769956233708887934477609633504801472827442743,
+        14056248655941725362944552761799461694550787028230120190862133165195793034373,
+        14124396743304355958915937804966111851843703158171757752158388556919187839849,
+        11851254356749068692552943732920045260402277343008629727465773766468466181076,
+        9799099446406796696742256539758943483211846559715874347178722060519817626047,
+        10156146186214948683880719664738535455146137901666656566575307300522957959544,
+        19908645952733301583346063785055921934459499091029406575311417879963332475861,
+        11766105336238068471342414351862472329437473380853789942065610694000443387471,
+        11002137593249972174092192767251572171769044073555430468487809799220351297047,
+        284136377911685911941431040940403846843630064858778505937392780738953624163,
+        19448733709802908339787967270452055364068697565906862913410983275341804035680,
+        14423660424692802524250720264041003098290275890428483723270346403986712981505,
+        10635360132728137321700090133109897687122647659471659996419791842933639708516
    ];

    var M = [
        [
-            12037235000515189726428793905458162231976011685774991261061889278958802340039,
-            15885254491685089152627111704751054604879027605518712546805347341940526552948,
-            12220682901774309471330657931458552366575439534877271150866614914170639536810,
-            11195096069395318710866553226959674457987772316145705151894647995087349332576,
-            598000700605575401177173118514166571064818339748567530524299773749024042768,
-            1430722853270801285936618367966028727146977818314178365893636191280860605092
+            19167410339349846567561662441069598364702008768579734801591448511131028229281,
+            14183033936038168803360723133013092560869148726790180682363054735190196956789,
+            9067734253445064890734144122526450279189023719890032859456830213166173619761,
+            16378664841697311562845443097199265623838619398287411428110917414833007677155,
+            12968540216479938138647596899147650021419273189336843725176422194136033835172,
+            3636162562566338420490575570584278737093584021456168183289112789616069756675
        ],[
-            2478807512283787086755520696277192042388812450777005645736937700857950416751,
-            2233078558675693495109307103888903813217767160310116996267068037131890781382,
-            18876120310576321787684235034151243856925703159922712959767164734820803570163,
-            16850806847813838898693870637445284830832219430572133120914449039176718036761,
-            1333036876405396107763619427367607232034082504897380383847654332653606615427,
-            8024813862822108072341428765418554797098705487914663416123759888639403831315
+            17034139127218860091985397764514160131253018178110701196935786874261236172431,
+            2799255644797227968811798608332314218966179365168250111693473252876996230317,
+            2482058150180648511543788012634934806465808146786082148795902594096349483974,
+            16563522740626180338295201738437974404892092704059676533096069531044355099628,
+            10468644849657689537028565510142839489302836569811003546969773105463051947124,
+            3328913364598498171733622353010907641674136720305714432354138807013088636408
        ],[
-            6500095533434910955474026763873910167129305339747639394388586826716085593160,
-            8370208895752773828195461153114215021863221486187756770286440396339432061839,
-            9303960191058819387902927958335344077259478983903385066838134730814638010892,
-            12233235273183315334651707749232602313616943260130930740801007863528547113209,
-            9140649423847813564210562288927015604065254723368331178903734405333716165919,
-            1715897011776785698388835993891828784112980527691698420841641796168725014542
+            18985203040268814769637347880759846911264240088034262814847924884273017355969,
+            8652975463545710606098548415650457376967119951977109072274595329619335974180,
+            970943815872417895015626519859542525373809485973005165410533315057253476903,
+            19406667490568134101658669326517700199745817783746545889094238643063688871948,
+            17049854690034965250221386317058877242629221002521630573756355118745574274967,
+            4964394613021008685803675656098849539153699842663541444414978877928878266244
        ],[
-            19092640119254952117901733765506685707486610088248205883870061221436629780176,
-            3099417239661426161523333446616746096617346084970490427773391639810420659748,
-            4498351799178816410443394768364090919370619407529999860500200773846156676605,
-            17766546613911504681964882079687098358108049762069064124348111606619240189874,
-            19735199036142202254810745273503942799136628866093225336283966579447096889407,
-            18618071352177331467649099054615438672487187348128402045695624605978242597928
+            19025623051770008118343718096455821045904242602531062247152770448380880817517,
+            9077319817220936628089890431129759976815127354480867310384708941479362824016,
+            4770370314098695913091200576539533727214143013236894216582648993741910829490,
+            4298564056297802123194408918029088169104276109138370115401819933600955259473,
+            6905514380186323693285869145872115273350947784558995755916362330070690839131,
+            4783343257810358393326889022942241108539824540285247795235499223017138301952
        ],[
-            13282641901514824677915134398195165361567825236648422290753355584311135817423,
-            842963276112770184096507757019973399127531993386626262873928307889423235104,
-            5724939764407712239242783736588389538981693110806985476155198757555171230777,
-            3015568820237516884743892014063659856564948150197038824747891972506031149123,
-            8926202997251578932273751544826990276848999132609774201265891812369804099098,
-            13523975980414815337318802343464374889255493007711857898760066111901192774093
+            16205238342129310687768799056463408647672389183328001070715567975181364448609,
+            8303849270045876854140023508764676765932043944545416856530551331270859502246,
+            20218246699596954048529384569730026273241102596326201163062133863539137060414,
+            1712845821388089905746651754894206522004527237615042226559791118162382909269,
+            13001155522144542028910638547179410124467185319212645031214919884423841839406,
+            16037892369576300958623292723740289861626299352695838577330319504984091062115
        ],[
-            13163705634211158833717167498904899472888572514300041636511944020589976373689,
-            6705743158328622712684686369234272301477431173971663001146157949982901448493,
-            5341285785102635724684809992160578025785996331334612975598752577556138916495,
-            2365134732811643517126128253974711531515283135672252986518431351700239265326,
-            11812366860142870031000585328436207067560705932658624313008187741187899702321,
-            11192751017231920972897699839932659451476356148115786649719660565307185769796
+            15162889384227198851506890526431746552868519326873025085114621698588781611738,
+            13272957914179340594010910867091459756043436017766464331915862093201960540910,
+            9416416589114508529880440146952102328470363729880726115521103179442988482948,
+            8035240799672199706102747147502951589635001418759394863664434079699838251138,
+            21642389080762222565487157652540372010968704000567605990102641816691459811717,
+            20261355950827657195644012399234591122288573679402601053407151083849785332516
        ]
    ];

+
    signal input inputs[nInputs];
    signal output out;

--- a/circuits/sha256/sha256.circom
+++ b/circuits/sha256/sha256.circom
@@ -0,0 +1,81 @@
+
+
+include "constants.circom";
+include "sha256compression.circom";
+
+template Sha256(nBits) {
+    signal input in[nBits];
+    signal output out[256];
+
+    var i;
+    var k;
+    var nBlocks;
+    var bitsLastBlock;
+
+
+    nBlocks = ((nBits + 64)\512)+1;
+
+    signal paddedIn[nBlocks*512];
+
+    for (k=0; k<nBits; k++) {
+        paddedIn[k] <== in[k];
+    }
+    paddedIn[nBits] <== 1;
+
+    for (k=nBits+1; k<nBlocks*512-64; k++) {
+        paddedIn[k] <== 0;
+    }
+
+    for (k = 0; k< 64; k++) {
+        paddedIn[nBlocks*512 - k -1] <== (nBits >> k)&1;
+    }
+
+    component ha0 = H(0);
+    component hb0 = H(1);
+    component hc0 = H(2);
+    component hd0 = H(3);
+    component he0 = H(4);
+    component hf0 = H(5);
+    component hg0 = H(6);
+    component hh0 = H(7);
+
+    component sha256compression[nBlocks];
+
+    for (i=0; i<nBlocks; i++) {
+
+        sha256compression[i] = Sha256compression() ;
+
+        if (i==0) {
+            for (k=0; k<32; k++ ) {
+                sha256compression[i].hin[0*32+k] <== ha0.out[k];
+                sha256compression[i].hin[1*32+k] <== hb0.out[k];
+                sha256compression[i].hin[2*32+k] <== hc0.out[k];
+                sha256compression[i].hin[3*32+k] <== hd0.out[k];
+                sha256compression[i].hin[4*32+k] <== he0.out[k];
+                sha256compression[i].hin[5*32+k] <== hf0.out[k];
+                sha256compression[i].hin[6*32+k] <== hg0.out[k];
+                sha256compression[i].hin[7*32+k] <== hh0.out[k];
+            }
+        } else {
+            for (k=0; k<32; k++ ) {
+                sha256compression[i].hin[32*0+k] <== sha256compression[i-1].out[32*0+31-k];
+                sha256compression[i].hin[32*1+k] <== sha256compression[i-1].out[32*1+31-k];
+                sha256compression[i].hin[32*2+k] <== sha256compression[i-1].out[32*2+31-k];
+                sha256compression[i].hin[32*3+k] <== sha256compression[i-1].out[32*3+31-k];
+                sha256compression[i].hin[32*4+k] <== sha256compression[i-1].out[32*4+31-k];
+                sha256compression[i].hin[32*5+k] <== sha256compression[i-1].out[32*5+31-k];
+                sha256compression[i].hin[32*6+k] <== sha256compression[i-1].out[32*6+31-k];
+                sha256compression[i].hin[32*7+k] <== sha256compression[i-1].out[32*7+31-k];
+            }
+        }
+
+        for (k=0; k<512; k++) {
+            sha256compression[i].inp[k] <== paddedIn[i*512+k];
+        }
+    }
+
+    for (k=0; k<256; k++) {
+        out[k] <== sha256compression[nBlocks-1].out[k];
+    }
+
+}
--- a/circuits/sha256/sha256_2.circom
+++ b/circuits/sha256/sha256_2.circom
@@ -17,6 +17,7 @@
    along with circom. If not, see <https://www.gnu.org/licenses/>.
 */

+include "constants.circom";
 include "sha256compression.circom";
 include "../bitify.circom"

@@ -25,6 +26,9 @@ template Sha256_2() {
    signal input b;
    signal output out;

+    var i;
+    var k;
+
    component bits2num = Bits2Num(216);
    component num2bits[2];

@@ -34,9 +38,28 @@ template Sha256_2() {
    num2bits[0].in <== a;
    num2bits[1].in <== b;

+
    component sha256compression = Sha256compression() ;

-    var i;
+    component ha0 = H(0);
+    component hb0 = H(1);
+    component hc0 = H(2);
+    component hd0 = H(3);
+    component he0 = H(4);
+    component hf0 = H(5);
+    component hg0 = H(6);
+    component hh0 = H(7);
+
+    for (k=0; k<32; k++ ) {
+        sha256compression.hin[0*32+k] <== ha0.out[k];
+        sha256compression.hin[1*32+k] <== hb0.out[k];
+        sha256compression.hin[2*32+k] <== hc0.out[k];
+        sha256compression.hin[3*32+k] <== hd0.out[k];
+        sha256compression.hin[4*32+k] <== he0.out[k];
+        sha256compression.hin[5*32+k] <== hf0.out[k];
+        sha256compression.hin[6*32+k] <== hg0.out[k];
+        sha256compression.hin[7*32+k] <== hh0.out[k];
+    }

    for (i=0; i<216; i++) {
        sha256compression.inp[i] <== num2bits[0].out[215-i];
--- a/circuits/sha256/sha256compression.circom
+++ b/circuits/sha256/sha256compression.circom
@@ -24,6 +24,7 @@ include "../binsum.circom";
 include "sigmaplus.circom";

 template Sha256compression() {
+    signal input hin[256];
    signal input inp[512];
    signal output out[256];
    signal a[65][32];
@@ -44,15 +45,6 @@ template Sha256compression() {
    component ct_k[64];
    for (i=0; i<64; i++) ct_k[i] = K(i);

-    component ha0 = H(0);
-    component hb0 = H(1);
-    component hc0 = H(2);
-    component hd0 = H(3);
-    component he0 = H(4);
-    component hf0 = H(5);
-    component hg0 = H(6);
-    component hh0 = H(7);
-
    component t1[64];
    for (i=0; i<64; i++) t1[i] = T1();

@@ -88,14 +80,14 @@ template Sha256compression() {
    }

    for (k=0; k<32; k++ ) {
-        a[0][k] <== ha0.out[k]
-        b[0][k] <== hb0.out[k]
-        c[0][k] <== hc0.out[k]
-        d[0][k] <== hd0.out[k]
-        e[0][k] <== he0.out[k]
-        f[0][k] <== hf0.out[k]
-        g[0][k] <== hg0.out[k]
-        h[0][k] <== hh0.out[k]
+        a[0][k] <== hin[k];
+        b[0][k] <== hin[32*1 + k];
+        c[0][k] <== hin[32*2 + k];
+        d[0][k] <== hin[32*3 + k];
+        e[0][k] <== hin[32*4 + k];
+        f[0][k] <== hin[32*5 + k];
+        g[0][k] <== hin[32*6 + k];
+        h[0][k] <== hin[32*7 + k];
    }

    for (t = 0; t<64; t++) {
@@ -133,21 +125,21 @@ template Sha256compression() {
    }

    for (k=0; k<32; k++) {
-        fsum[0].in[0][k] <==  ha0.out[k];
+        fsum[0].in[0][k] <==  hin[32*0+k];
        fsum[0].in[1][k] <==  a[64][k];
-        fsum[1].in[0][k] <==  hb0.out[k];
+        fsum[1].in[0][k] <==  hin[32*1+k];
        fsum[1].in[1][k] <==  b[64][k];
-        fsum[2].in[0][k] <==  hc0.out[k];
+        fsum[2].in[0][k] <==  hin[32*2+k];
        fsum[2].in[1][k] <==  c[64][k];
-        fsum[3].in[0][k] <==  hd0.out[k];
+        fsum[3].in[0][k] <==  hin[32*3+k];
        fsum[3].in[1][k] <==  d[64][k];
-        fsum[4].in[0][k] <==  he0.out[k];
+        fsum[4].in[0][k] <==  hin[32*4+k];
        fsum[4].in[1][k] <==  e[64][k];
-        fsum[5].in[0][k] <==  hf0.out[k];
+        fsum[5].in[0][k] <==  hin[32*5+k];
        fsum[5].in[1][k] <==  f[64][k];
-        fsum[6].in[0][k] <==  hg0.out[k];
+        fsum[6].in[0][k] <==  hin[32*6+k];
        fsum[6].in[1][k] <==  g[64][k];
-        fsum[7].in[0][k] <==  hh0.out[k];
+        fsum[7].in[0][k] <==  hin[32*7+k];
        fsum[7].in[1][k] <==  h[64][k];
    }

--- a/index.js
+++ b/index.js
@@ -4,3 +4,6 @@ exports.mimc7 = require("./src/mimc7");
 exports.mimcsponge = require("./src/mimcsponge");
 exports.babyJub = require("./src/babyjub");
 exports.pedersenHash = require("./src/pedersenHash");
+exports.SMT = require("./src/smt").SMT;
+exports.SMTMemDB = require("./src/smt_memdb");
+exports.poseidon = require("./src/poseidon");
--- a/log.txt
+++ b/log.txt
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,21 +1,21 @@
 {
  "name": "circomlib",
-  "version": "0.0.9",
+  "version": "0.0.18",
  "lockfileVersion": 1,
  "requires": true,
  "dependencies": {
    "@babel/code-frame": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.0.0.tgz",
-      "integrity": "sha512-OfC2uemaknXr87bdLUkWog7nYuliM9Ij5HUcajsVcMCpQrcLmtxRbVFTIqmcSkSeYRBFBRxs2FiUqFJDLdiebA==",
+      "version": "7.5.5",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.5.5.tgz",
+      "integrity": "sha512-27d4lZoomVyo51VegxI20xZPuSHusqbQag/ztrBC7wegWoQ1nLREPVSKSW8byhTlzTKyNE4ifaTA6lCp7JjpFw==",
      "requires": {
        "@babel/highlight": "^7.0.0"
      }
    },
    "@babel/highlight": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.0.0.tgz",
-      "integrity": "sha512-UFMC4ZeFC48Tpvj7C8UgLvtkaUuovQX+5xNWrsIoMG8o2z+XFKjKaN9iVmS84dPwVN00W4wPmqvYoZF3EGAsfw==",
+      "version": "7.5.0",
+      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.5.0.tgz",
+      "integrity": "sha512-7dV4eu9gBxoM0dAnj/BCFDW9LFU0zvTrkq0ugM7pnHEgguOEeOz1so2ZghEdzviYzQEED0r4EAgpsBChKy1TRQ==",
      "requires": {
        "chalk": "^2.0.0",
        "esutils": "^2.0.2",
@@ -44,20 +44,31 @@
      "integrity": "sha512-QcAKpaO6nhHLlxWBvpc4WeLrTvPqlHOvaj0s5GriKkA1zq+bsFBPpfYCvQhLqLgYlIko8A9YrPdaMHCo5mBcpg=="
    },
    "acorn": {
-      "version": "6.1.1",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-6.1.1.tgz",
-      "integrity": "sha512-jPTiwtOxaHNaAPg/dmrJ/beuzLRnXtB0kQPQ8JpotKJgTB6rX6c8mlf315941pyjBSaPg8NHXS9fhP4u17DpGA=="
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-6.3.0.tgz",
+      "integrity": "sha512-/czfa8BwS88b9gWQVhc8eknunSA2DoJpJyTQkhheIf5E48u1N0R4q/YxxsAeqRrmK9TQ/uYfgLDfZo91UlANIA=="
    },
    "acorn-jsx": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.0.1.tgz",
-      "integrity": "sha512-HJ7CfNHrfJLlNTzIEUTj43LNWGkqpRLxm3YjAlcD0ACydk9XynzYsCBHxut+iqt+1aBXkx9UP/w/ZqMr13XIzg=="
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.0.2.tgz",
+      "integrity": "sha512-tiNTrP1MP0QrChmD2DdupCr6HWSFeKVw5d/dHTu4Y7rkAkRhU/Dt7dphAfIUyxtHpl/eBVip5uTNSpQJHylpAw=="
    },
    "aes-js": {
      "version": "3.0.0",
      "resolved": "https://registry.npmjs.org/aes-js/-/aes-js-3.0.0.tgz",
      "integrity": "sha1-4h3xCtbCBTKVvLuNq0Cwnb6ofk0="
    },
+    "ajv": {
+      "version": "6.10.2",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.10.2.tgz",
+      "integrity": "sha512-TXtUUEYHuaTEbLZWIKUr5pmBuhDLy+8KYtPYdcV8qC+pOZL+NKqYwvWSRrVXHn+ZmRRAu8vJTAznH7Oag6RVRw==",
+      "requires": {
+        "fast-deep-equal": "^2.0.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      }
+    },
    "ansi-colors": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-1.1.0.tgz",
@@ -337,9 +348,9 @@
      }
    },
    "big-integer": {
-      "version": "1.6.43",
-      "resolved": "https://registry.npmjs.org/big-integer/-/big-integer-1.6.43.tgz",
-      "integrity": "sha512-9dULc9jsKmXl0Aeunug8wbF+58n+hQoFjqClN7WeZwGLh0XJUWyJJ9Ee+Ep+Ql/J9fRsTVaeThp8MhiCCrY0Jg=="
+      "version": "1.6.44",
+      "resolved": "https://registry.npmjs.org/big-integer/-/big-integer-1.6.44.tgz",
+      "integrity": "sha512-7MzElZPTyJ2fNvBkPxtFQ2fWIkVmuzw41+BZHSzpEq3ymB2MfeKp1+yXl/tS75xCx+WnyV+yb0kp+K1C3UNwmQ=="
    },
    "binary-extensions": {
      "version": "1.13.1",
@@ -347,9 +358,12 @@
      "integrity": "sha512-Un7MIEDdUC5gNpcGDV97op1Ywk748MpHcFTHoYs6qnj1Z3j7I53VG3nwZhKzoBZmbdRNnb6WRdFlwl7tSDuZGw=="
    },
    "bindings": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.3.0.tgz",
-      "integrity": "sha512-DpLh5EzMR2kzvX1KIlVC0VkC3iZtHKTgdtZ0a3pglBZdaQFjt5S9g9xd1lE+YvXyfd6mtCeRnrUfOLYiTMlNSw=="
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz",
+      "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==",
+      "requires": {
+        "file-uri-to-path": "1.0.0"
+      }
    },
    "bip66": {
      "version": "1.1.5",
@@ -369,6 +383,23 @@
        "nan": "^2.2.1"
      }
    },
+    "blake2b": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/blake2b/-/blake2b-2.1.3.tgz",
+      "integrity": "sha512-pkDss4xFVbMb4270aCyGD3qLv92314Et+FsKzilCLxDz5DuZ2/1g3w4nmBbu6nKApPspnjG7JcwTjGZnduB1yg==",
+      "requires": {
+        "blake2b-wasm": "^1.1.0",
+        "nanoassert": "^1.0.0"
+      }
+    },
+    "blake2b-wasm": {
+      "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/blake2b-wasm/-/blake2b-wasm-1.1.7.tgz",
+      "integrity": "sha512-oFIHvXhlz/DUgF0kq5B1CqxIDjIJwh9iDeUUGQUcvgiGz7Wdw03McEO7CfLBy7QKGdsydcMCgO9jFNBAFCtFcA==",
+      "requires": {
+        "nanoassert": "^1.0.0"
+      }
+    },
    "bn.js": {
      "version": "4.11.8",
      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.8.tgz",
@@ -693,7 +724,7 @@
    },
    "commander": {
      "version": "2.15.1",
-      "resolved": "http://registry.npmjs.org/commander/-/commander-2.15.1.tgz",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-2.15.1.tgz",
      "integrity": "sha512-VlfT9F3V0v+jr4yxPc5gg9s62/fIVWsd2Bk2iD435um1NlGMYdVCq+MjcXnhYq2icNOizHr1kK+5TI6H0Hy0ag==",
      "dev": true
    },
@@ -1114,28 +1145,15 @@
        "strip-json-comments": "^2.0.1",
        "table": "^5.2.3",
        "text-table": "^0.2.0"
-      },
-      "dependencies": {
-        "ajv": {
-          "version": "6.10.0",
-          "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.10.0.tgz",
-          "integrity": "sha512-nffhOpkymDECQyR0mnsUtoCE8RlX38G0rYP+wgLWFyZuUyuuojSSvi/+euOiQBIn63whYwYVIIH1TvE3tu4OEg==",
-          "requires": {
-            "fast-deep-equal": "^2.0.1",
-            "fast-json-stable-stringify": "^2.0.0",
-            "json-schema-traverse": "^0.4.1",
-            "uri-js": "^4.2.2"
-          }
-        }
      }
    },
    "eslint-plugin-mocha": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-mocha/-/eslint-plugin-mocha-5.2.0.tgz",
-      "integrity": "sha512-4VTX/qIoxUFRnXLNm6bEhEJyfGnGagmQzV4TWXKzkZgIYyP2FSubEdCjEFTyS/dGwSVRWCWGX7jO7BK8R0kppg==",
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-mocha/-/eslint-plugin-mocha-5.3.0.tgz",
+      "integrity": "sha512-3uwlJVLijjEmBeNyH60nzqgA1gacUWLUmcKV8PIGNvj1kwP/CTgAWQHn2ayyJVwziX+KETkr9opNwT1qD/RZ5A==",
      "dev": true,
      "requires": {
-        "ramda": "^0.25.0"
+        "ramda": "^0.26.1"
      }
    },
    "eslint-scope": {
@@ -1148,14 +1166,17 @@
      }
    },
    "eslint-utils": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-1.3.1.tgz",
-      "integrity": "sha512-Z7YjnIldX+2XMcjr7ZkgEsOj/bREONV60qYeB/bjMAqqqZ4zxKyWX+BOUkdmRmA9riiIPVvo5x86m5elviOk0Q=="
+      "version": "1.4.2",
+      "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-1.4.2.tgz",
+      "integrity": "sha512-eAZS2sEUMlIeCjBeubdj45dmBHQwPHWyBcT1VSYB7o9x9WRRqKxyUoiXlRjyAwzN7YEzHJlYg0NmzDRWx6GP4Q==",
+      "requires": {
+        "eslint-visitor-keys": "^1.0.0"
+      }
    },
    "eslint-visitor-keys": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.0.0.tgz",
-      "integrity": "sha512-qzm/XxIbxm/FHyH341ZrbnMUpe+5Bocte9xkmFMzPMjRaZMcXww+MpBptFvtU+79L362nqiLhekCxCxDPaUMBQ=="
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.1.0.tgz",
+      "integrity": "sha512-8y9YjtM1JBJU/A9Kc+SbaOV4y29sSWckBwMHa+FGtVj5gN/sbnKDf6xJUl+8g7FAij9LVaP8C24DUiH/f/2Z9A=="
    },
    "espree": {
      "version": "5.0.1",
@@ -1189,14 +1210,14 @@
      }
    },
    "estraverse": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz",
-      "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM="
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz",
+      "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw=="
    },
    "esutils": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.2.tgz",
-      "integrity": "sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs="
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="
    },
    "eth-ens-namehash": {
      "version": "2.0.8",
@@ -1335,16 +1356,6 @@
        "p-finally": "^1.0.0",
        "signal-exit": "^3.0.0",
        "strip-eof": "^1.0.0"
-      },
-      "dependencies": {
-        "get-stream": {
-          "version": "4.1.0",
-          "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz",
-          "integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==",
-          "requires": {
-            "pump": "^3.0.0"
-          }
-        }
      }
    },
    "expand-brackets": {
@@ -1425,9 +1436,9 @@
      }
    },
    "external-editor": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.0.3.tgz",
-      "integrity": "sha512-bn71H9+qWoOQKyZDo25mOMVpSmXROAsTJVVVYzrrtol3d4y+AsKjf4Iwl2Q+IuT0kFSQ1qo166UuIwqYq7mGnA==",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz",
+      "integrity": "sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==",
      "requires": {
        "chardet": "^0.7.0",
        "iconv-lite": "^0.4.24",
@@ -1605,22 +1616,12 @@
        "flatted": "^2.0.0",
        "rimraf": "2.6.3",
        "write": "1.0.3"
-      },
-      "dependencies": {
-        "rimraf": {
-          "version": "2.6.3",
-          "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz",
-          "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==",
-          "requires": {
-            "glob": "^7.1.3"
-          }
-        }
      }
    },
    "flatted": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/flatted/-/flatted-2.0.0.tgz",
-      "integrity": "sha512-R+H8IZclI8AAkSBRQJLVOsxwAoHd6WC40b4QTNWIjzAa6BXOBfQcM587MXDTVPeYaopFNWHUFLx7eNmHDSxMWg=="
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-2.0.1.tgz",
+      "integrity": "sha512-a1hQMktqW9Nmqr5aktAux3JMNqaucxGcjtjWnZLHX7yyPCmlSV3M54nGYbqT8K+0GhF3NBgmJCc3ma+WOgX8Jg=="
    },
    "flush-write-stream": {
      "version": "1.1.1",
@@ -1907,12 +1908,6 @@
          "bundled": true,
          "optional": true
        },
-        "nan": {
-          "version": "2.14.0",
-          "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.0.tgz",
-          "integrity": "sha512-INOFj37C7k3AfaNTtX8RhsTw7qRy7eLET14cROi9+5HAVbbHuIWUHEauBv5qT4Av2tWasiTY1Jw6puUNqRJXQg==",
-          "optional": true
-        },
        "needle": {
          "version": "2.3.0",
          "bundled": true,
@@ -2560,15 +2555,23 @@
      "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.0.tgz",
      "integrity": "sha1-6td0q+5y4gQJQzoGY2YCPdaIekE="
    },
+    "get-stream": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz",
+      "integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==",
+      "requires": {
+        "pump": "^3.0.0"
+      }
+    },
    "get-value": {
      "version": "2.0.6",
      "resolved": "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz",
      "integrity": "sha1-3BXKHGcjh8p2vTesCjlbogQqLCg="
    },
    "glob": {
-      "version": "7.1.3",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz",
-      "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==",
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.4.tgz",
+      "integrity": "sha512-hkLPepehmnKk41pUGm3sYxoFs/umurYfYJCerbXEyFIWcAzvpipAgVkBqqT9RBKMGjnq6kMuyYwha6csxbiM1A==",
      "requires": {
        "fs.realpath": "^1.0.0",
        "inflight": "^1.0.4",
@@ -2956,9 +2959,9 @@
      "integrity": "sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg=="
    },
    "import-fresh": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.0.0.tgz",
-      "integrity": "sha512-pOnA9tfM3Uwics+SaBLCNyZZZbK+4PTu0OPZtLlMIrv17EdBoC15S9Kn8ckJ9TZTyKb3ywNE5y1yeDxxGA7nTQ==",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.1.0.tgz",
+      "integrity": "sha512-PpuksHKGt8rXfWEr9m9EHIpgyyaltBy8+eF6GJM0QCAxMgxCfucMF3mjecK2QsJr0amJW7gTqh5/wht0z2UhEQ==",
      "requires": {
        "parent-module": "^1.0.0",
        "resolve-from": "^4.0.0"
@@ -2979,9 +2982,9 @@
      }
    },
    "inherits": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
-      "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4="
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
    },
    "ini": {
      "version": "1.3.5",
@@ -2989,9 +2992,9 @@
      "integrity": "sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw=="
    },
    "inquirer": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-6.3.1.tgz",
-      "integrity": "sha512-MmL624rfkFt4TG9y/Jvmt8vdmOo836U7Y0Hxr2aFk3RelZEGX4Igk0KabWrcaaZaTv9uzglOqWh1Vly+FAWAXA==",
+      "version": "6.5.2",
+      "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-6.5.2.tgz",
+      "integrity": "sha512-cntlB5ghuB0iuO65Ovoi8ogLHiWGs/5yNrtUcKjFhSSiVeAIVpD7koaSU9RM8mpXw5YDi9RdYXGQMaOURB7ycQ==",
      "requires": {
        "ansi-escapes": "^3.2.0",
        "chalk": "^2.4.2",
@@ -2999,7 +3002,7 @@
        "cli-width": "^2.0.0",
        "external-editor": "^3.0.3",
        "figures": "^2.0.0",
-        "lodash": "^4.17.11",
+        "lodash": "^4.17.12",
        "mute-stream": "0.0.7",
        "run-async": "^2.2.0",
        "rxjs": "^6.4.0",
@@ -3393,9 +3396,9 @@
      }
    },
    "lodash": {
-      "version": "4.17.11",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.11.tgz",
-      "integrity": "sha512-cQKh8igo5QUhZ7lg38DYWAxMvjSAKG0A8wGSVimP07SIUEK2UO+arSRKbRZWtelMtN5V0Hkwh5ryOto/SshYIg=="
+      "version": "4.17.15",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.15.tgz",
+      "integrity": "sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A=="
    },
    "make-iterator": {
      "version": "1.0.1",
@@ -3542,10 +3545,9 @@
      }
    },
    "minimist": {
-      "version": "0.0.10",
-      "resolved": "http://registry.npmjs.org/minimist/-/minimist-0.0.10.tgz",
-      "integrity": "sha1-3j+YVD2/lggr5IrRoMfNqDYwHc8=",
-      "dev": true
+      "version": "0.0.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz",
+      "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0="
    },
    "mixin-deep": {
      "version": "1.3.2",
@@ -3568,17 +3570,10 @@
    },
    "mkdirp": {
      "version": "0.5.1",
-      "resolved": "http://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz",
      "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=",
      "requires": {
        "minimist": "0.0.8"
-      },
-      "dependencies": {
-        "minimist": {
-          "version": "0.0.8",
-          "resolved": "http://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz",
-          "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0="
-        }
      }
    },
    "mocha": {
@@ -3641,9 +3636,9 @@
      }
    },
    "ms": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
-      "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg=="
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
    },
    "mute-stdout": {
      "version": "1.0.1",
@@ -3656,9 +3651,14 @@
      "integrity": "sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s="
    },
    "nan": {
-      "version": "2.11.1",
-      "resolved": "https://registry.npmjs.org/nan/-/nan-2.11.1.tgz",
-      "integrity": "sha512-iji6k87OSXa0CcrLl9z+ZiYSuR2o+c0bGuNmXdrhTQTakxytAFsC56SArGYoiHlJlFoHSnvmhpceZJaXkVuOtA=="
+      "version": "2.14.0",
+      "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.0.tgz",
+      "integrity": "sha512-INOFj37C7k3AfaNTtX8RhsTw7qRy7eLET14cROi9+5HAVbbHuIWUHEauBv5qT4Av2tWasiTY1Jw6puUNqRJXQg=="
+    },
+    "nanoassert": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/nanoassert/-/nanoassert-1.1.0.tgz",
+      "integrity": "sha1-TzFS4JVA/eKMdvRLGbvNHVpCR40="
    },
    "nanomatch": {
      "version": "1.2.13",
@@ -3867,6 +3867,14 @@
      "requires": {
        "minimist": "~0.0.1",
        "wordwrap": "~0.0.2"
+      },
+      "dependencies": {
+        "wordwrap": {
+          "version": "0.0.3",
+          "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.3.tgz",
+          "integrity": "sha1-o9XabNXAvAAI03I0u68b7WMFkQc=",
+          "dev": true
+        }
      }
    },
    "optionator": {
@@ -3880,13 +3888,6 @@
        "prelude-ls": "~1.1.2",
        "type-check": "~0.3.2",
        "wordwrap": "~1.0.0"
-      },
-      "dependencies": {
-        "wordwrap": {
-          "version": "1.0.0",
-          "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz",
-          "integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus="
-        }
      }
    },
    "ordered-read-streams": {
@@ -4167,9 +4168,9 @@
      "integrity": "sha512-w7fLxIRCRT7U8Qu53jQnJyPkYZIaR4n5151KMfcJlO/A9397Wxb1amJvROTK6TOnp7PfoAmg/qXiNHI+08jRfA=="
    },
    "ramda": {
-      "version": "0.25.0",
-      "resolved": "https://registry.npmjs.org/ramda/-/ramda-0.25.0.tgz",
-      "integrity": "sha512-GXpfrYVPwx3K7RQ6aYT8KPS8XViSXUVJT1ONhoKPE9VAleW42YE+U+8VEyGWt41EnEQW7gwecYJriTI0pKoecQ==",
+      "version": "0.26.1",
+      "resolved": "https://registry.npmjs.org/ramda/-/ramda-0.26.1.tgz",
+      "integrity": "sha512-hLWjpy7EnsDBb0p+Z3B7rPi3GDeRG5ZtiI33kJhTt+ORCd38AbAIjB/9zRIUoeTbE/AVX5ZkU7m6bznsvrf8eQ==",
      "dev": true
    },
    "randombytes": {
@@ -4389,6 +4390,14 @@
      "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz",
      "integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg=="
    },
+    "rimraf": {
+      "version": "2.6.3",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz",
+      "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==",
+      "requires": {
+        "glob": "^7.1.3"
+      }
+    },
    "ripemd160": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz",
@@ -4485,21 +4494,6 @@
        "elliptic": "^6.4.1",
        "nan": "^2.14.0",
        "safe-buffer": "^5.1.2"
-      },
-      "dependencies": {
-        "bindings": {
-          "version": "1.5.0",
-          "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz",
-          "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==",
-          "requires": {
-            "file-uri-to-path": "1.0.0"
-          }
-        },
-        "nan": {
-          "version": "2.14.0",
-          "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.0.tgz",
-          "integrity": "sha512-INOFj37C7k3AfaNTtX8RhsTw7qRy7eLET14cROi9+5HAVbbHuIWUHEauBv5qT4Av2tWasiTY1Jw6puUNqRJXQg=="
-        }
      }
    },
    "semver": {
@@ -4709,15 +4703,29 @@
      }
    },
    "snarkjs": {
-      "version": "0.1.11",
-      "resolved": "https://registry.npmjs.org/snarkjs/-/snarkjs-0.1.11.tgz",
-      "integrity": "sha512-NoMNn03Uwbt18V340ZlHSZscyfIu8F6fMOL7LT9Xr1zQY/nmzScM8442ATyJfzSI5bDTAz1QQGbCerP2BCKljA==",
+      "version": "0.1.18",
+      "resolved": "https://registry.npmjs.org/snarkjs/-/snarkjs-0.1.18.tgz",
+      "integrity": "sha512-JWZMBvPPIL424+QCY0PtreIiHTRoX4h4qYvKv3nqKPVZl0T7sw3B/ZeizrCVRz7Jr9vrwZxmzJ0XIg6D1yC8Mg==",
      "requires": {
-        "big-integer": "^1.6.35",
-        "chai": "^4.1.2",
+        "big-integer": "^1.6.43",
+        "chai": "^4.2.0",
        "escape-string-regexp": "^1.0.5",
-        "eslint": "^5.3.0",
-        "yargs": "^12.0.2"
+        "eslint": "^5.16.0",
+        "keccak": "^2.0.0",
+        "yargs": "^12.0.5"
+      },
+      "dependencies": {
+        "keccak": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/keccak/-/keccak-2.0.0.tgz",
+          "integrity": "sha512-rKe/lRr0KGhjoz97cwg+oeT1Rj/Y4cjae6glArioUC8JBF9ROGZctwIaaruM7d7naovME4Q8WcQSO908A8qcyQ==",
+          "requires": {
+            "bindings": "^1.2.1",
+            "inherits": "^2.0.3",
+            "nan": "^2.2.1",
+            "safe-buffer": "^5.1.0"
+          }
+        }
      }
    },
    "source-map": {
@@ -4879,7 +4887,7 @@
    },
    "strip-eof": {
      "version": "1.0.0",
-      "resolved": "http://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz",
+      "resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz",
      "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8="
    },
    "strip-hex-prefix": {
@@ -4913,27 +4921,16 @@
      }
    },
    "table": {
-      "version": "5.4.0",
-      "resolved": "https://registry.npmjs.org/table/-/table-5.4.0.tgz",
-      "integrity": "sha512-nHFDrxmbrkU7JAFKqKbDJXfzrX2UBsWmrieXFTGxiI5e4ncg3VqsZeI4EzNmX0ncp4XNGVeoxIWJXfCIXwrsvw==",
+      "version": "5.4.6",
+      "resolved": "https://registry.npmjs.org/table/-/table-5.4.6.tgz",
+      "integrity": "sha512-wmEc8m4fjnob4gt5riFRtTu/6+4rSe12TpAELNSqHMfF3IqnA+CH37USM6/YR3qRZv7e56kAEAtd6nKZaxe0Ug==",
      "requires": {
-        "ajv": "^6.9.1",
-        "lodash": "^4.17.11",
+        "ajv": "^6.10.2",
+        "lodash": "^4.17.14",
        "slice-ansi": "^2.1.0",
        "string-width": "^3.0.0"
      },
      "dependencies": {
-        "ajv": {
-          "version": "6.10.0",
-          "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.10.0.tgz",
-          "integrity": "sha512-nffhOpkymDECQyR0mnsUtoCE8RlX38G0rYP+wgLWFyZuUyuuojSSvi/+euOiQBIn63whYwYVIIH1TvE3tu4OEg==",
-          "requires": {
-            "fast-deep-equal": "^2.0.1",
-            "fast-json-stable-stringify": "^2.0.0",
-            "json-schema-traverse": "^0.4.1",
-            "uri-js": "^4.2.2"
-          }
-        },
        "ansi-regex": {
          "version": "4.1.0",
          "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz",
@@ -4966,7 +4963,7 @@
    },
    "through": {
      "version": "2.3.8",
-      "resolved": "http://registry.npmjs.org/through/-/through-2.3.8.tgz",
+      "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
      "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU="
    },
    "through2": {
@@ -5061,9 +5058,9 @@
      }
    },
    "tslib": {
-      "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.9.3.tgz",
-      "integrity": "sha512-4krF8scpejhaOgqzBEcGM7yDIEfi0/8+8zDRZhNZZ2kjmHJ4hv3zCbQWxoJGz1iw5U0Jl0nma13xzHXcncMavQ=="
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.10.0.tgz",
+      "integrity": "sha512-qOebF53frne81cf0S9B41ByenJ3/IuH8yJKngAX35CmiZySA0khhkovshKK+jGCaMnVomla7gVlIcc3EvKPbTQ=="
    },
    "type": {
      "version": "1.0.1",
@@ -5598,14 +5595,13 @@
      "integrity": "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho="
    },
    "wordwrap": {
-      "version": "0.0.3",
-      "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.3.tgz",
-      "integrity": "sha1-o9XabNXAvAAI03I0u68b7WMFkQc=",
-      "dev": true
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz",
+      "integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus="
    },
    "wrap-ansi": {
      "version": "2.1.0",
-      "resolved": "http://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz",
      "integrity": "sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=",
      "requires": {
        "string-width": "^1.0.1",
@@ -5627,7 +5623,7 @@
        },
        "string-width": {
          "version": "1.0.2",
-          "resolved": "http://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz",
+          "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz",
          "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=",
          "requires": {
            "code-point-at": "^1.0.0",
@@ -5637,7 +5633,7 @@
        },
        "strip-ansi": {
          "version": "3.0.1",
-          "resolved": "http://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
+          "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz",
          "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=",
          "requires": {
            "ansi-regex": "^2.0.0"
@@ -5705,9 +5701,9 @@
      "integrity": "sha1-Z/4HXFwk/vOfnWX197f+dRcZaPw="
    },
    "xtend": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz",
-      "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68="
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ=="
    },
    "y18n": {
      "version": "4.0.0",
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "circomlib",
-  "version": "0.0.9",
+  "version": "0.0.18",
  "description": "Basic circuits library for Circom",
  "main": "index.js",
  "directories": {
@@ -25,12 +25,13 @@
  "license": "GPL-3.0",
  "dependencies": {
    "blake-hash": "^1.1.0",
-    "snarkjs": "0.1.11",
+    "blake2b": "^2.1.3",
+    "snarkjs": "^0.1.20",
    "typedarray-to-buffer": "^3.1.5",
    "web3": "^1.0.0-beta.55"
  },
  "devDependencies": {
-    "circom": "0.0.28",
+    "circom": "0.0.32",
    "eslint-plugin-mocha": "^5.2.0",
    "ganache-cli": "^6.4.4",
    "mocha": "^5.2.0"
--- a/src/babyjub.js
+++ b/src/babyjub.js
@@ -7,19 +7,23 @@ exports.inCurve = inCurve;
 exports.inSubgroup = inSubgroup;
 exports.packPoint = packPoint;
 exports.unpackPoint = unpackPoint;
+exports.Generator = [
+    bigInt("995203441582195749578291179787384436505546430278305826713579947235728471134"),
+    bigInt("5472060717959818805561601436314318772137091100104008585924551046643952123905")
+];
 exports.Base8 = [
-    bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
-    bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475")
+    bigInt("5299619240641551281634865583518297030282874472190772894086521144482721001553"),
+    bigInt("16950150798460657717958625567821834550301663161624707787222815936182638968203")
 ];
 exports.order = bigInt("21888242871839275222246405745257275088614511777268538073601725287587578984328");
 exports.subOrder = exports.order.shr(3);
 exports.p = bn128.r;
+exports.A = bigInt("168700");
+exports.D = bigInt("168696");


 function addPoint(a,b) {
    const q = bn128.r;
-    const cta = bigInt("168700");
-    const d = bigInt("168696");

    const res = [];

@@ -27,8 +31,8 @@ function addPoint(a,b) {
     res[0] = bigInt((a[0]*b[1] + b[0]*a[1]) *  bigInt(bigInt("1") + d*a[0]*b[0]*a[1]*b[1]).inverse(q)).affine(q);
    res[1] = bigInt((a[1]*b[1] - cta*a[0]*b[0]) * bigInt(bigInt("1") - d*a[0]*b[0]*a[1]*b[1]).inverse(q)).affine(q);
    */
-    res[0] = bigInt((bigInt(a[0]).mul(b[1]).add(bigInt(b[0]).mul(a[1]))).mul(bigInt(bigInt("1").add(d.mul(a[0]).mul(b[0]).mul(a[1]).mul(b[1]))).inverse(q))).affine(q);
-    res[1] = bigInt((bigInt(a[1]).mul(b[1]).sub(cta.mul(a[0]).mul(b[0]))).mul(bigInt(bigInt("1").sub(d.mul(a[0]).mul(b[0]).mul(a[1]).mul(b[1]))).inverse(q))).affine(q);
+    res[0] = bigInt((bigInt(a[0]).mul(b[1]).add(bigInt(b[0]).mul(a[1]))).mul(bigInt(bigInt("1").add(exports.D.mul(a[0]).mul(b[0]).mul(a[1]).mul(b[1]))).inverse(q))).affine(q);
+    res[1] = bigInt((bigInt(a[1]).mul(b[1]).sub(exports.A.mul(a[0]).mul(b[0]))).mul(bigInt(bigInt("1").sub(exports.D.mul(a[0]).mul(b[0]).mul(a[1]).mul(b[1]))).inverse(q))).affine(q);

    return res;
 }
@@ -58,15 +62,12 @@ function inSubgroup(P) {
 function inCurve(P) {
    const F = bn128.Fr;

-    const a = bigInt("168700");
-    const d = bigInt("168696");
-
    const x2 = F.square(P[0]);
    const y2 = F.square(P[1]);

    if (!F.equals(
-        F.add(F.mul(a, x2), y2),
-        F.add(F.one, F.mul(F.mul(x2, y2), d)))) return false;
+        F.add(F.mul(exports.A, x2), y2),
+        F.add(F.one, F.mul(F.mul(x2, y2), exports.D)))) return false;

    return true;
 }
@@ -92,14 +93,11 @@ function unpackPoint(_buff) {
    P[1] = bigInt.leBuff2int(buff);
    if (P[1].greaterOrEquals(exports.p)) return null;

-    const a = bigInt("168700");
-    const d = bigInt("168696");
-
    const y2 = F.square(P[1]);

    let x = F.sqrt(F.div(
        F.sub(F.one, y2),
-        F.sub(a, F.mul(d, y2))));
+        F.sub(exports.A, F.mul(exports.D, y2))));

    if (x == null) return null;

--- a/src/poseidon.js
+++ b/src/poseidon.js
@@ -1,6 +1,6 @@
 const bn128 = require("snarkjs").bn128;
 const bigInt = require("snarkjs").bigInt;
-const createBlakeHash = require("blake-hash");
+const blake2b = require('blake2b');
 const assert = require("assert");
 const F = bn128.Fr;

@@ -11,11 +11,12 @@ const T = 6;

 function getPseudoRandom(seed, n) {
    const res = [];
-    let h = createBlakeHash("blake256").update(seed).digest();
+    let input = Buffer.from(seed);
+    let h = blake2b(32).update(input).digest()
    while (res.length<n) {
        const n = F.affine(bigInt.leBuff2int(h));
        res.push(n);
-        h = createBlakeHash("blake256").update(h).digest();
+        h = blake2b(32).update(h).digest()
    }

    return res;
@@ -94,7 +95,7 @@ exports.createHash = (t, nRoundsF, nRoundsP, seed) => {
    const M = exports.getMatrix(t, seed, nRoundsF + nRoundsP);
    return function(inputs) {
        let state = [];
-        assert(inputs.length < t);
+        assert(inputs.length <= t);
        assert(inputs.length > 0);
        for (let i=0; i<inputs.length; i++) state[i] = bigInt(inputs[i]);
        for (let i=inputs.length; i<t; i++) state[i] = F.zero;
--- a/src/smt.js
+++ b/src/smt.js
@@ -309,3 +309,5 @@ async function newMemEmptyTrie() {

 module.exports.loadFromFile = loadFromFile;
 module.exports.newMemEmptyTrie = newMemEmptyTrie;
+module.exports.SMT = SMT;
+module.exports.SMTMemDB = SMTMemDB;
--- a/test/babyjub_js.js
+++ b/test/babyjub_js.js
@@ -0,0 +1,166 @@
+const chai = require("chai");
+const path = require("path");
+const snarkjs = require("snarkjs");
+const compiler = require("circom");
+const babyjub = require("../src/babyjub.js");
+
+const assert = chai.assert;
+
+// const bigInt = require("big-integer");
+
+
+describe("Baby Jub js test", function () {
+
+    this.timeout(100000);
+
+    it("Should add point (0,1) and (0,1)", () => {
+
+        const p1 = [
+            snarkjs.bigInt(0),
+            snarkjs.bigInt(1)];
+        const p2 = [
+            snarkjs.bigInt(0),
+            snarkjs.bigInt(1)
+        ];
+
+        const out = babyjub.addPoint(p1, p2)
+        assert(out[0].equals(0));
+        assert(out[1].equals(1));
+    });
+
+    it("Should base be 8*generator", () => {
+        let res;
+        res = babyjub.addPoint(babyjub.Generator, babyjub.Generator);
+        res = babyjub.addPoint(res, res);
+        res = babyjub.addPoint(res, res);
+
+        assert(res[0].equals(babyjub.Base8[0]));
+        assert(res[1].equals(babyjub.Base8[1]));
+    });
+
+    it("Should add 2 same numbers", () => {
+
+        const p1 = [
+            snarkjs.bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
+            snarkjs.bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475"),
+        ];
+        const p2 = [
+            snarkjs.bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
+            snarkjs.bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475"),
+        ];
+
+        const out = babyjub.addPoint(p1, p2)
+        assert(out[0].equals(snarkjs.bigInt("6890855772600357754907169075114257697580319025794532037257385534741338397365")));
+        assert(out[1].equals(snarkjs.bigInt("4338620300185947561074059802482547481416142213883829469920100239455078257889")));
+    });
+
+    it("Should add 2 different numbers", () => {
+
+        const p1 = [
+            snarkjs.bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
+            snarkjs.bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475"),
+        ];
+        const p2 = [
+            snarkjs.bigInt("16540640123574156134436876038791482806971768689494387082833631921987005038935"),
+            snarkjs.bigInt("20819045374670962167435360035096875258406992893633759881276124905556507972311"),
+        ];
+
+        const out = babyjub.addPoint(p1, p2)
+
+        assert(out[0].equals(snarkjs.bigInt("7916061937171219682591368294088513039687205273691143098332585753343424131937")));
+        assert(out[1].equals(snarkjs.bigInt("14035240266687799601661095864649209771790948434046947201833777492504781204499")));
+    });
+
+    it("should mulPointEscalar 0", () => {
+        const p = [
+            snarkjs.bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
+            snarkjs.bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475"),
+        ];
+
+        const r = babyjub.mulPointEscalar(p, snarkjs.bigInt("3"));
+        let r2 = babyjub.addPoint(p, p);
+        r2 = babyjub.addPoint(r2, p);
+        assert.equal(r2[0].toString(), r[0].toString());
+        assert.equal(r2[1].toString(), r[1].toString());
+        assert.equal(r[0].toString(), "19372461775513343691590086534037741906533799473648040012278229434133483800898");
+        assert.equal(r[1].toString(), "9458658722007214007257525444427903161243386465067105737478306991484593958249");
+    });
+
+    it("should mulPointEscalar 1", () => {
+        const p = [
+            snarkjs.bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
+            snarkjs.bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475"),
+        ];
+
+        const r = babyjub.mulPointEscalar(p, snarkjs.bigInt("14035240266687799601661095864649209771790948434046947201833777492504781204499"));
+        assert.equal(r[0].toString(), "17070357974431721403481313912716834497662307308519659060910483826664480189605");
+        assert.equal(r[1].toString(), "4014745322800118607127020275658861516666525056516280575712425373174125159339");
+    });
+
+    it("should mulPointEscalar 2", () => {
+        const p = [
+            snarkjs.bigInt("6890855772600357754907169075114257697580319025794532037257385534741338397365"),
+            snarkjs.bigInt("4338620300185947561074059802482547481416142213883829469920100239455078257889"),
+        ];
+
+        const r = babyjub.mulPointEscalar(p, snarkjs.bigInt("20819045374670962167435360035096875258406992893633759881276124905556507972311"));
+        assert.equal(r[0].toString(), "13563888653650925984868671744672725781658357821216877865297235725727006259983");
+        assert.equal(r[1].toString(), "8442587202676550862664528699803615547505326611544120184665036919364004251662");
+    });
+
+    it("should inCurve 1", () => {
+        const p = [
+            snarkjs.bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
+            snarkjs.bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475"),
+        ];
+        assert(babyjub.inCurve(p));
+    });
+
+    it("should inCurve 2", () => {
+        const p = [
+            snarkjs.bigInt("6890855772600357754907169075114257697580319025794532037257385534741338397365"),
+            snarkjs.bigInt("4338620300185947561074059802482547481416142213883829469920100239455078257889"),
+        ];
+        assert(babyjub.inCurve(p));
+    });
+
+    it("should inSubgroup 1", () => {
+        const p = [
+            snarkjs.bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
+            snarkjs.bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475"),
+        ];
+        assert(babyjub.inSubgroup(p));
+    });
+
+    it("should inSubgroup 2", () => {
+        const p = [
+            snarkjs.bigInt("6890855772600357754907169075114257697580319025794532037257385534741338397365"),
+            snarkjs.bigInt("4338620300185947561074059802482547481416142213883829469920100239455078257889"),
+        ];
+        assert(babyjub.inSubgroup(p));
+    });
+
+    it("should packPoint - unpackPoint 1", () => {
+        const p = [
+            snarkjs.bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
+            snarkjs.bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475"),
+        ];
+        const buf = babyjub.packPoint(p);
+        assert.equal(buf.toString('hex'), '53b81ed5bffe9545b54016234682e7b2f699bd42a5e9eae27ff4051bc698ce85');
+        const p2 = babyjub.unpackPoint(buf);
+        assert.equal(p2[0].toString(), "17777552123799933955779906779655732241715742912184938656739573121738514868268");
+        assert.equal(p2[1].toString(), "2626589144620713026669568689430873010625803728049924121243784502389097019475");
+    });
+
+    it("should packPoint - unpackPoint 2", () => {
+        const p = [
+            snarkjs.bigInt("6890855772600357754907169075114257697580319025794532037257385534741338397365"),
+            snarkjs.bigInt("4338620300185947561074059802482547481416142213883829469920100239455078257889"),
+        ];
+        const buf = babyjub.packPoint(p);
+        assert.equal(buf.toString('hex'), 'e114eb17eddf794f063a68fecac515e3620e131976108555735c8b0773929709');
+        const p2 = babyjub.unpackPoint(buf);
+        assert.equal(p2[0].toString(), "6890855772600357754907169075114257697580319025794532037257385534741338397365");
+        assert.equal(p2[1].toString(), "4338620300185947561074059802482547481416142213883829469920100239455078257889");
+    });
+});
--- a/test/circuits/escalarmul_min_test.circom
+++ b/test/circuits/escalarmul_min_test.circom
@@ -7,8 +7,8 @@ template Main() {

    var i;

-    var base = [17777552123799933955779906779655732241715742912184938656739573121738514868268,
-                2626589144620713026669568689430873010625803728049924121243784502389097019475]
+    var base = [5299619240641551281634865583518297030282874472190772894086521144482721001553,
+                16950150798460657717958625567821834550301663161624707787222815936182638968203]

    component escalarMul = EscalarMul(256, base);

--- a/test/circuits/escalarmul_test.circom
+++ b/test/circuits/escalarmul_test.circom
@@ -6,8 +6,8 @@ template Main() {
    signal input in;
    signal output out[2];

-    var base = [17777552123799933955779906779655732241715742912184938656739573121738514868268,
-            2626589144620713026669568689430873010625803728049924121243784502389097019475]
+    var base = [5299619240641551281634865583518297030282874472190772894086521144482721001553,
+            16950150798460657717958625567821834550301663161624707787222815936182638968203]


    component n2b = Num2Bits(253);
--- a/test/circuits/escalarmul_test_min.circom
+++ b/test/circuits/escalarmul_test_min.circom
@@ -7,8 +7,8 @@ template Main() {

    var i;

-    var base = [17777552123799933955779906779655732241715742912184938656739573121738514868268,
-                2626589144620713026669568689430873010625803728049924121243784502389097019475]
+    var base = [5299619240641551281634865583518297030282874472190772894086521144482721001553,
+                16950150798460657717958625567821834550301663161624707787222815936182638968203]

    component escalarMul = EscalarMul(256, base);

--- a/test/circuits/escalarmulfix_test.circom
+++ b/test/circuits/escalarmulfix_test.circom
@@ -6,8 +6,8 @@ template Main() {
    signal input e;
    signal output out[2];

-    var base = [17777552123799933955779906779655732241715742912184938656739573121738514868268,
-            2626589144620713026669568689430873010625803728049924121243784502389097019475]
+    var base = [5299619240641551281634865583518297030282874472190772894086521144482721001553,
+            16950150798460657717958625567821834550301663161624707787222815936182638968203]


    component n2b = Num2Bits(253);
--- a/test/circuits/escalarmulw4table.circom
+++ b/test/circuits/escalarmulw4table.circom
@@ -1,6 +1,6 @@
 include "../../circuits/escalarmulw4table.circom";

-var base = [17777552123799933955779906779655732241715742912184938656739573121738514868268,
-            2626589144620713026669568689430873010625803728049924121243784502389097019475]
+var base = [5299619240641551281634865583518297030282874472190772894086521144482721001553,
+            16950150798460657717958625567821834550301663161624707787222815936182638968203]

 component main = EscalarMulW4Table(base, 0);
--- a/test/circuits/escalarmulw4table_test.circom
+++ b/test/circuits/escalarmulw4table_test.circom
@@ -1,6 +1,17 @@
 include "../../circuits/escalarmulw4table.circom";

-var base = [17777552123799933955779906779655732241715742912184938656739573121738514868268,
-            2626589144620713026669568689430873010625803728049924121243784502389097019475];

-component main = EscalarMulW4Table(base, 0);
+template Main() {
+    signal input in;
+    signal output out[16][2];
+    var base = [5299619240641551281634865583518297030282874472190772894086521144482721001553,
+                16950150798460657717958625567821834550301663161624707787222815936182638968203];
+
+    component escalarMul = EscalarMulW4Table(base, 0);
+    for (var i=0; i<16; i++) {
+        out[i][0] <== escalarMul.out[i][0]*in;
+        out[i][1] <== escalarMul.out[i][1]*in;
+    }
+}
+
+component main = Main();
--- a/test/circuits/escalarmulw4table_test3.circom
+++ b/test/circuits/escalarmulw4table_test3.circom
@@ -1,6 +1,17 @@
 include "../../circuits/escalarmulw4table.circom";

-var base = [17777552123799933955779906779655732241715742912184938656739573121738514868268,
-            2626589144620713026669568689430873010625803728049924121243784502389097019475]

-component main = EscalarMulW4Table(base, 3);
+template Main() {
+    signal input in;
+    signal output out[16][2];
+    var base = [5299619240641551281634865583518297030282874472190772894086521144482721001553,
+                16950150798460657717958625567821834550301663161624707787222815936182638968203];
+
+    component escalarMul = EscalarMulW4Table(base, 3);
+    for (var i=0; i<16; i++) {
+        out[i][0] <== escalarMul.out[i][0]*in;
+        out[i][1] <== escalarMul.out[i][1]*in;
+    }
+}
+
+component main = Main();
--- a/test/circuits/sha256_test448.circom
+++ b/test/circuits/sha256_test448.circom
@@ -0,0 +1,3 @@
+include "../../circuits/sha256/sha256.circom";
+
+component main = Sha256(448);
--- a/test/circuits/sha256_test512.circom
+++ b/test/circuits/sha256_test512.circom
@@ -0,0 +1,3 @@
+include "../../circuits/sha256/sha256.circom";
+
+component main = Sha256(512);
--- a/test/eddsa_js.js
+++ b/test/eddsa_js.js
@@ -0,0 +1,82 @@
+const chai = require("chai");
+const snarkjs = require("snarkjs");
+
+const eddsa = require("../src/eddsa.js");
+const babyJub = require("../src/babyjub.js");
+
+const assert = chai.assert;
+
+const bigInt = snarkjs.bigInt;
+
+describe("EdDSA js test", function () {
+
+    this.timeout(100000);
+
+    it("Sign (using Mimc7) a single 10 bytes from 0 to 9", () => {
+        const msgBuf = Buffer.from("00010203040506070809", "hex");
+        const msg = bigInt.leBuff2int(msgBuf);
+
+        //  const prvKey = crypto.randomBytes(32);
+
+        const prvKey = Buffer.from("0001020304050607080900010203040506070809000102030405060708090001", "hex");
+
+        const pubKey = eddsa.prv2pub(prvKey);
+
+        assert.equal(pubKey[0].toString(),
+            "13277427435165878497778222415993513565335242147425444199013288855685581939618");
+        assert.equal(pubKey[1].toString(),
+            "13622229784656158136036771217484571176836296686641868549125388198837476602820");
+
+        const pPubKey = babyJub.packPoint(pubKey);
+
+        const signature = eddsa.signMiMC(prvKey, msg);
+        assert.equal(signature.R8[0].toString(),
+            "11384336176656855268977457483345535180380036354188103142384839473266348197733");
+        assert.equal(signature.R8[1].toString(),
+            "15383486972088797283337779941324724402501462225528836549661220478783371668959");
+        assert.equal(signature.S.toString(),
+            "2523202440825208709475937830811065542425109372212752003460238913256192595070");
+
+        const pSignature = eddsa.packSignature(signature);
+        assert.equal(pSignature.toString("hex"), ""+
+            "dfedb4315d3f2eb4de2d3c510d7a987dcab67089c8ace06308827bf5bcbe02a2"+
+            "7ed40dab29bf993c928e789d007387998901a24913d44fddb64b1f21fc149405");
+
+        const uSignature = eddsa.unpackSignature(pSignature);
+        assert(eddsa.verifyMiMC(msg, uSignature, pubKey));
+
+    });
+
+    it("Sign (using Poseidon) a single 10 bytes from 0 to 9", () => {
+        const msgBuf = Buffer.from("00010203040506070809", "hex");
+        const msg = bigInt.leBuff2int(msgBuf);
+
+        const prvKey = Buffer.from("0001020304050607080900010203040506070809000102030405060708090001", "hex");
+
+        const pubKey = eddsa.prv2pub(prvKey);
+
+        assert.equal(pubKey[0].toString(),
+            "13277427435165878497778222415993513565335242147425444199013288855685581939618");
+        assert.equal(pubKey[1].toString(),
+            "13622229784656158136036771217484571176836296686641868549125388198837476602820");
+
+        const pPubKey = babyJub.packPoint(pubKey);
+
+        const signature = eddsa.signPoseidon(prvKey, msg);
+        assert.equal(signature.R8[0].toString(),
+            "11384336176656855268977457483345535180380036354188103142384839473266348197733");
+        assert.equal(signature.R8[1].toString(),
+            "15383486972088797283337779941324724402501462225528836549661220478783371668959");
+        assert.equal(signature.S.toString(),
+            "248298168863866362217836334079793350221620631973732197668910946177382043688");
+
+        const pSignature = eddsa.packSignature(signature);
+        assert.equal(pSignature.toString("hex"), ""+
+            "dfedb4315d3f2eb4de2d3c510d7a987dcab67089c8ace06308827bf5bcbe02a2"+
+            "28506bce274aa1b3f7e7c2fd7e4fe09bff8f9aa37a42def7994e98f322888c00");
+
+        const uSignature = eddsa.unpackSignature(pSignature);
+        assert(eddsa.verifyPoseidon(msg, uSignature, pubKey));
+
+    });
+});
--- a/test/escalarmul.js
+++ b/test/escalarmul.js
@@ -36,10 +36,10 @@ describe("Exponentioation test", () => {

        console.log("NConstrains: " + circuit.nConstraints);

-        const w = circuit.calculateWitness({});
+        const w = circuit.calculateWitness({in: 1});

-        let g = [bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
-                 bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475")]
+        let g = [bigInt("5299619240641551281634865583518297030282874472190772894086521144482721001553"),
+                 bigInt("16950150798460657717958625567821834550301663161624707787222815936182638968203")]

        dbl= [bigInt("0"), snarkjs.bigInt("1")];

@@ -72,10 +72,10 @@ describe("Exponentioation test", () => {

        console.log("NConstrains: " + circuit.nConstraints);

-        const w = circuit.calculateWitness({});
+        const w = circuit.calculateWitness({in: 1});

-        let g = [snarkjs.bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
-                 snarkjs.bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475")]
+        let g = [snarkjs.bigInt("5299619240641551281634865583518297030282874472190772894086521144482721001553"),
+                 snarkjs.bigInt("16950150798460657717958625567821834550301663161624707787222815936182638968203")]

        for (let i=0; i<12;i++) {
            g = addPoint(g,g);
@@ -116,8 +116,8 @@ describe("Exponentioation test", () => {

        assert(circuit.checkWitness(w));

-        let g = [snarkjs.bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
-                 snarkjs.bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475")]
+        let g = [snarkjs.bigInt("5299619240641551281634865583518297030282874472190772894086521144482721001553"),
+                 snarkjs.bigInt("16950150798460657717958625567821834550301663161624707787222815936182638968203")]

        let c = [0n, 1n];

--- a/test/escalarmulany.js
+++ b/test/escalarmulany.js
@@ -18,8 +18,8 @@ describe("Escalarmul test", function () {
    this.timeout(100000);

    let g = [
-        snarkjs.bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
-        snarkjs.bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475")
+        snarkjs.bigInt("5299619240641551281634865583518297030282874472190772894086521144482721001553"),
+        snarkjs.bigInt("16950150798460657717958625567821834550301663161624707787222815936182638968203")
    ];

    before( async() => {
--- a/test/escalarmulfix.js
+++ b/test/escalarmulfix.js
@@ -50,6 +50,51 @@ describe("Escalarmul test", function () {
        assert(yout.equals(babyjub.Base8[1]));
    });

+    it("Should generate scalar mul of a specific constant", async () => {
+
+        const s = bigInt("2351960337287830298912035165133676222414898052661454064215017316447594616519");
+        const base8 = [
+            bigInt("5299619240641551281634865583518297030282874472190772894086521144482721001553"),
+            bigInt("16950150798460657717958625567821834550301663161624707787222815936182638968203")
+        ];
+
+        const w = circuit.calculateWitness({"e": s});
+
+        assert(circuit.checkWitness(w));
+
+        const xout = w[circuit.getSignalIdx("main.out[0]")];
+        const yout = w[circuit.getSignalIdx("main.out[1]")];
+
+        const expectedRes = babyjub.mulPointEscalar(base8, s);
+
+        assert(xout.equals(expectedRes[0]));
+        assert(yout.equals(expectedRes[1]));
+    });
+
+    it("Should generate scalar mul of the firsts 50 elements", async () => {
+
+        const base8 = [
+            bigInt("5299619240641551281634865583518297030282874472190772894086521144482721001553"),
+            bigInt("16950150798460657717958625567821834550301663161624707787222815936182638968203")
+        ];
+
+        for (let i=0; i<50; i++) {
+            const s = bigInt(i);
+
+            const w = circuit.calculateWitness({"e": s});
+
+            assert(circuit.checkWitness(w));
+
+            const xout = w[circuit.getSignalIdx("main.out[0]")];
+            const yout = w[circuit.getSignalIdx("main.out[1]")];
+
+            const expectedRes = babyjub.mulPointEscalar(base8, s);
+
+            assert(xout.equals(expectedRes[0]));
+            assert(yout.equals(expectedRes[1]));
+        }
+    });
+
    it("If multiply by order should return 0", async () => {

        const w = circuit.calculateWitness({"e": babyjub.subOrder });
--- a/test/montgomery.js
+++ b/test/montgomery.js
@@ -15,8 +15,8 @@ describe("Montgomery test", function () {
    let circuitMDouble;

    let g = [
-        snarkjs.bigInt("17777552123799933955779906779655732241715742912184938656739573121738514868268"),
-        snarkjs.bigInt("2626589144620713026669568689430873010625803728049924121243784502389097019475")];
+        snarkjs.bigInt("5299619240641551281634865583518297030282874472190772894086521144482721001553"),
+        snarkjs.bigInt("16950150798460657717958625567821834550301663161624707787222815936182638968203")];

    let mg, mg2, g2, g3, mg3;

--- a/test/poseidoncircuit.js
+++ b/test/poseidoncircuit.js
@@ -2,11 +2,21 @@ const chai = require("chai");
 const path = require("path");
 const snarkjs = require("snarkjs");
 const compiler = require("circom");
+var blake2b = require('blake2b');

 const poseidon = require("../src/poseidon.js");

 const assert = chai.assert;

+describe("Blake2b version test", function() {
+    it("Should give the expected output for blake2b version", async () => {
+        var output = new Uint8Array(32);
+        var input = Buffer.from('poseidon_constants');
+        h = blake2b(output.length).update(input).digest('hex')
+        assert.equal('e57ba154fb2c47811dc1a2369b27e25a44915b4e4ece4eb8ec74850cb78e01b1', h);
+    });
+});
+
 describe("Poseidon Circuit test", function () {
    let circuit;

@@ -20,7 +30,7 @@ describe("Poseidon Circuit test", function () {
        console.log("Poseidon constraints: " + circuit.nConstraints);
    });

-    it("Should check constrain", async () => {
+    it("Should check constrain of hash([1, 2])", async () => {
        const w = circuit.calculateWitness({inputs: [1, 2]});

        const res = w[circuit.getSignalIdx("main.out")];
@@ -28,12 +38,23 @@ describe("Poseidon Circuit test", function () {
        const hash = poseidon.createHash(6, 8, 57);

        const res2 = hash([1,2]);
+        assert.equal('12242166908188651009877250812424843524687801523336557272219921456462821518061', res2.toString());
+        assert.equal(res.toString(), res2.toString());
+        assert(circuit.checkWitness(w));
+    });

-        console.log(res.toString());
+    it("Should check constrain of hash([3, 4])", async () => {
+        const w = circuit.calculateWitness({inputs: [3, 4]});
+
+        const res = w[circuit.getSignalIdx("main.out")];
+
+        const hash = poseidon.createHash(6, 8, 57);
+
+        const res2 = hash([3, 4]);
+        assert.equal('17185195740979599334254027721507328033796809509313949281114643312710535000993', res2.toString());

        assert.equal(res.toString(), res2.toString());

        assert(circuit.checkWitness(w));
-
    });
 });
--- a/test/sha256.js
+++ b/test/sha256.js
@@ -12,8 +12,43 @@ const sha256 = require("./helpers/sha256");
 // const printSignal = require("./helpers/printsignal");


+function buffer2bitArray(b) {
+    const res = [];
+    for (let i=0; i<b.length; i++) {
+        for (let j=0; j<8; j++) {
+            res.push((b[i] >> (7-j) &1));
+        }
+    }
+    return res;
+}
+
+function bitArray2buffer(a) {
+    const len = Math.floor((a.length -1 )/8)+1;
+    const b = new Buffer.alloc(len);
+
+    for (let i=0; i<a.length; i++) {
+        const p = Math.floor(i/8);
+        b[p] = b[p] | (Number(a[i]) << ( 7 - (i%8)  ));
+    }
+    return b;
+}
+
+
 describe("SHA256 test", () => {
-    it("Should calculate a hash", async () => {
+
+
+    it("Should work bits to array and array to bits", async () => {
+        const b = new Buffer.alloc(64);
+        for (let i=0; i<64; i++) {
+            b[i] = i+1;
+        }
+        const a = buffer2bitArray(b);
+        const b2 = bitArray2buffer(a);
+
+        assert.equal(b.toString("hex"), b2.toString("hex"));
+    });
+
+    it("Should calculate a hash of 1 compressor", async () => {
        const cirDef = await compiler(path.join(__dirname, "circuits", "sha256_2_test.circom"));
        const circuit = new snarkjs.Circuit(cirDef);

@@ -38,5 +73,64 @@ describe("SHA256 test", () => {
        assert(witness[1].equals(snarkjs.bigInt(r)));
    }).timeout(1000000);

+    it("Should calculate a hash of 2 compressor", async () => {
+        const cirDef = await compiler(path.join(__dirname, "circuits", "sha256_test512.circom"),  {reduceConstraints:false}  );
+        const circuit = new snarkjs.Circuit(cirDef);

+        console.log("Vars: "+circuit.nVars);
+        console.log("Constraints: "+circuit.nConstraints);
+
+/*
+        const testStr = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
+
+        const b = Buffer.from(testStr, 'utf8');
+*/
+        const b = new Buffer.alloc(64);
+        for (let i=0; i<64; i++) {
+            b[i] = i+1;
+        }
+
+        const hash = crypto.createHash("sha256")
+            .update(b)
+            .digest("hex");
+
+        const arrIn = buffer2bitArray(b);
+        const witness = circuit.calculateWitness({ "in": arrIn } /*, {logOutput: true} */);
+
+        const arrOut = witness.slice(1, 257);
+        const hash2 = bitArray2buffer(arrOut).toString("hex");
+
+        assert.equal(hash, hash2);
+
+    }).timeout(1000000);
+
+
+    it("Should calculate a hash of 2 compressor", async () => {
+        const cirDef = await compiler(path.join(__dirname, "circuits", "sha256_test448.circom"),  {reduceConstraints:false}  );
+        const circuit = new snarkjs.Circuit(cirDef);
+
+        console.log("Vars: "+circuit.nVars);
+        console.log("Constraints: "+circuit.nConstraints);
+
+
+        const testStr = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
+
+        const b = Buffer.from(testStr, 'utf8');
+        for (let i=0; i<64; i++) {
+            b[i] = i+1;
+        }
+
+        const hash = crypto.createHash("sha256")
+            .update(b)
+            .digest("hex");
+
+        const arrIn = buffer2bitArray(b);
+        const witness = circuit.calculateWitness({ "in": arrIn } /*, {logOutput: true} */);
+
+        const arrOut = witness.slice(1, 257);
+        const hash2 = bitArray2buffer(arrOut).toString("hex");
+
+        assert.equal(hash, hash2);
+
+    }).timeout(1000000);
 });
Author	SHA1	Message	Date
Jordi Baylina	5bf52cda57	Merge pull request #20 from bellesmarta/master Updated README files	2019-09-23 14:58:24 +02:00
Jordi Baylina	95abdd06d5	0.0.18	2019-09-17 07:57:45 +02:00
Jordi Baylina	9f69fab7c6	Merge pull request #22 from kobigurk/fix/mimcsponge_unconstrained mimcsponge: fixes assignment to outs[0]	2019-09-17 08:55:22 +03:00
Kobi Gurkan	109cdf4056	mimcsponge: fixes assignment to outs[0]	2019-09-17 08:53:02 +03:00
Jordi Baylina	79d30349b4	0.0.17	2019-09-15 10:52:50 +02:00
Jordi Baylina	e3cd0e5aa7	Dependencies and publish smt	2019-09-15 10:52:18 +02:00
Jordi Baylina	86e970b888	0.0.16	2019-09-07 20:23:18 +02:00
Jordi Baylina	29e162383d	Allow full poseidnon fix handle enable in the sigposeidon	2019-09-07 20:22:44 +02:00
Marta Belles	97b870b725	Updated README files	2019-09-06 17:14:45 +02:00
Jordi Baylina	f9e0484663	0.0.15	2019-09-05 17:12:56 +02:00
Jordi Baylina	7bdb254f4f	deps snarkjs	2019-09-05 17:12:47 +02:00
Jordi Baylina	024188b638	Support mutiply by point 0 in scalarmulany	2019-09-05 17:10:20 +02:00
Jordi Baylina	ebbeaebc73	Merge branch 'arnaucube-master'	2019-09-05 16:51:29 +02:00
Jordi Baylina	25f392c8ae	sha256 with number of bits as a paramter	2019-09-05 16:41:58 +02:00
Jordi Baylina	52a1fb895d	0.0.14	2019-08-30 10:38:19 +02:00
Jordi Baylina	1621483d3b	deps	2019-08-30 10:38:04 +02:00
arnaucube	ae362ec61b	add tests for babyjub eddsa poseidon sign & verify	2019-08-29 17:44:44 +02:00
Jordi Baylina	425f50a9ed	0.0.13	2019-08-24 19:53:41 +02:00
Jordi Baylina	173c17dedc	Change to a standard generator for Baby Jub	2019-08-03 12:46:21 +02:00
Jordi Baylina	23616427cd	0.0.12	2019-07-30 20:16:38 +02:00
Jordi Baylina	7c743659db	Fix escalarfix	2019-07-30 20:16:06 +02:00
Jordi Baylina	f04a318800	0.0.11	2019-07-30 19:35:35 +02:00
Jordi Baylina	b15c7c8089	FIX: escalarmul fix	2019-07-30 19:35:19 +02:00
Jordi Baylina	9282ffe8c3	0.0.10	2019-07-08 17:43:05 +02:00
Jordi Baylina	d5f02256f9	Merge branch 'feature/jstests'	2019-07-08 17:41:24 +02:00
Jordi Baylina	88acd49c0b	Merge branch 'master' into feature/jstests	2019-07-08 17:30:53 +02:00
Jordi Baylina	59f6e971cf	Merge branch 'arnaucube-master'	2019-07-08 17:28:11 +02:00
Jordi Baylina	da1cceed85	Merge branch 'master' of https://github.com/arnaucube/circomlib into arnaucube-master	2019-07-08 17:19:42 +02:00
arnaucube	3bc864f110	update poseidon with blake2b	2019-06-28 10:50:49 +02:00
Eduard S	0aabe6447d	Add babyjub and EdDSA js tests Add tests with vectors for javascript implementation of babyjub and EdDSA.	2019-05-16 13:16:59 +02:00