diff --git a/.eslintrc.js b/.eslintrc.js
index 32e2c671..ce75c5cf 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -24,7 +24,6 @@ module.exports = {
         "semi": [
             "error",
             "always"
-        ],
-        "mocha/no-exclusive-tests": "error"
+        ]
     }
 };
diff --git a/circuits/balancesupdater.circom b/circuits/balancesupdater.circom
index b3d59770..767c9fc5 100644
--- a/circuits/balancesupdater.circom
+++ b/circuits/balancesupdater.circom
@@ -8,7 +8,7 @@
 
    In case of an offChan TX the system does not allow it.
 
-   It also checks overflow of < 2^126
+   It also checks overflow of < 2^192
 */
 
 include "../node_modules/circomlib/circuits/bitify.circom";
@@ -19,9 +19,10 @@ template BalancesUpdater() {
     signal input oldStAmountRecieiver;
     signal input amount;
     signal input loadAmount;
-    signal input maxFee;
-    signal input minFee;
+    signal input userFee;
+    signal input operatorsFee;
     signal input onChain;
+    signal input nop;
     signal input countersIn;
     signal input countersBase;
 
@@ -30,41 +31,53 @@ template BalancesUpdater() {
     signal output countersOut;
     signal output update2;
 
-    signal limitsOk;
-    signal feeOk;
-    signal txOk;
+    signal feeApplies;      // 1 If fee applies (offChain) 0 if not applies (onChain)
+    signal appliedFee;      // amount of fee that needs to be discounted
 
-    component n2bSender = Num2Bits(127);
-    component n2bReceiver = Num2Bits(127);
+    signal limitsOk;        // 1 if from is >0 and <2**192
+    signal feeOk;           // If userFee > operatorFee
+    signal txOk;            // If both are ok.
+
+    signal effectiveAmount1;
+    signal effectiveAmount2;
+    signal effectiveLoadAmount;
+
+    component n2bSender = Num2Bits(193);
     component feeGE = GreaterEqThan(128);
-    component amountIsZero = IsZero();
+    component effectiveAmountIsZero = IsZero();
+
+    feeApplies <== (1-onChain)*(1-nop);  // Fee applies only on onChainTx and is not a NOP
 
-    amountIsZero.in <== amount;
+    appliedFee <== operatorsFee*feeApplies;
 
-    // Only apply fee if amount >0
-    signal applyFee;
-    applyFee <== minFee*(1- amountIsZero.out);
+    effectiveLoadAmount <== loadAmount*onChain;
+    effectiveAmount1 <== amount*(1-nop);
 
-    n2bSender.in <== (1<<126) + oldStAmountSender + loadAmount - (amount + applyFee);
-    n2bReceiver.in <== oldStAmountRecieiver + amount;
+    // Check limits and fees on limits
+    n2bSender.in <== (1<<192) + oldStAmountSender + effectiveLoadAmount - effectiveAmount1 - appliedFee;
 
-    feeGE.in[0] <== maxFee;
-    feeGE.in[1] <== applyFee;
+    // Fee offered by the user must be greater that the operators demanded
+    feeGE.in[0] <== userFee;
+    feeGE.in[1] <== operatorsFee;
 
     feeOk <== feeGE.out;
-    limitsOk <== (n2bSender.out[126])*(1-n2bReceiver.out[126]);
+    limitsOk <== n2bSender.out[192];
 
     txOk <== feeOk * limitsOk;
 
     // if not onChain and not txOk => error
     (1-txOk)*(1-onChain) === 0;
 
+    effectiveAmount2 <== txOk*effectiveAmount1;
+
+    effectiveAmountIsZero.in <== effectiveAmount2;
+
     // if !txOk then return 0;
-    newStAmountSender <== oldStAmountSender + loadAmount - (applyFee + amount)*txOk;
-    newStAmountReceiver <== oldStAmountRecieiver + amount*txOk
+    newStAmountSender <== oldStAmountSender + effectiveLoadAmount - effectiveAmount2 - appliedFee;
+    newStAmountReceiver <== oldStAmountRecieiver + effectiveAmount2
 
     // Counters
-    countersOut <== countersIn + countersBase*(1- amountIsZero.out);
-    update2 <== txOk * (1 - amountIsZero.out);
+    countersOut <== countersIn + countersBase*feeApplies;
+    update2 <== 1-effectiveAmountIsZero.out;
 
 }
diff --git a/circuits/decodetx.circom b/circuits/decodetx.circom
index b631972f..bb2ecee4 100644
--- a/circuits/decodetx.circom
+++ b/circuits/decodetx.circom
@@ -15,7 +15,7 @@ template DecodeTx(nLevels) {
     signal input previousOnChain;
     signal input oldOnChainHash;
     signal input txData;
-    signal input rqTxHash;
+    signal input rqTxData;
     signal input loadAmount;
     signal input ethAddr;
     signal input ax;
@@ -24,21 +24,21 @@ template DecodeTx(nLevels) {
     signal output fromIdx;       // 64        0..63
     signal output toIdx;         // 64       64..127
     signal output amount;        // 16      128..143
-    signal output coin;          // 16      144..159
-    signal output nonce;         // 48      160..207
-    signal output maxFee;        // 16      208..223
-    signal output rqOffset;      // 4       224..227
-    signal output onChain        // 1       228
-    signal output newAccount     // 1       229
-
-    signal output dataAvailabilityBits[nLevels*2+16+16];
+    signal output coin;          // 32      144..175
+    signal output nonce;         // 48      176..223
+    signal output userFee;       // 16      224..239
+    signal output rqOffset;      // 3       240..242
+    signal output onChain        // 1       243
+    signal output newAccount     // 1       244
+
+    signal output dataAvailabilityBits[nLevels*2+16];
     signal output offChainHash;  // For the signature
     signal output newOnChainHash;   // For the chained onchain
 
     var i;
     var IDEN3_ROLLUP_TX = 1625792389453394788515067275302403776356063435417596283072371667635754651289; // blake2b("IDEN3_ROLLUP_TX") % r
 
-    component n2bData = Num2Bits(230);
+    component n2bData = Num2Bits(245);
     n2bData.in <== txData;
 
 // from
@@ -77,8 +77,8 @@ template DecodeTx(nLevels) {
 
 // coin
 ////////
-    component b2nCoin = Bits2Num(16);
-    for (i=0; i<16; i++) {
+    component b2nCoin = Bits2Num(32);
+    for (i=0; i<32; i++) {
         b2nCoin.in[i] <== n2bData.out[144 + i];
     }
     b2nCoin.out ==> coin;
@@ -87,47 +87,44 @@ template DecodeTx(nLevels) {
 ////////
     component b2nNonce = Bits2Num(48);
     for (i=0; i<48; i++) {
-        b2nNonce.in[i] <== n2bData.out[160 + i];
+        b2nNonce.in[i] <== n2bData.out[176 + i];
     }
     b2nNonce.out ==> nonce;
 
-// maxFee
+// userFee
 ////////
-    component dfMaxFee = DecodeFloatBin();
+    component dfUserFee = DecodeFloatBin();
     for (i=0; i<16; i++) {
-        dfMaxFee.in[i] <== n2bData.out[208 + i];
+        dfUserFee.in[i] <== n2bData.out[224 + i];
     }
-    dfMaxFee.out ==> maxFee;
+    dfUserFee.out ==> userFee;
 
 // rqOffset
 ////////
-    component b2nRqOffset = Bits2Num(4);
-    for (i=0; i<4; i++) {
-        b2nRqOffset.in[i] <== n2bData.out[224 + i];
+    component b2nRqOffset = Bits2Num(3);
+    for (i=0; i<3; i++) {
+        b2nRqOffset.in[i] <== n2bData.out[240 + i];
     }
     b2nRqOffset.out ==> rqOffset;
 
 // onChain
 ////////
-    onChain <== n2bData.out[228];
+    onChain <== n2bData.out[243];
 
 // newAccount
 ////////
-    newAccount <== n2bData.out[229];
+    newAccount <== n2bData.out[244];
 
 //  Data Availability bits
 ////////
     for (i=0; i<nLevels; i++) {
-        dataAvailabilityBits[i] <== n2bData.out[i]*(1-onChain);
+        dataAvailabilityBits[nLevels - 1 - i] <== n2bData.out[i]*(1-onChain);
     }
     for (i=0; i<nLevels; i++) {
-        dataAvailabilityBits[nLevels + i] <== n2bData.out[64 + i]*(1-onChain);
-    }
-    for (i=0; i<16; i++) {
-        dataAvailabilityBits[nLevels*2 + i] <== n2bData.out[128 + i]*(1-onChain);
+        dataAvailabilityBits[nLevels + nLevels - 1 - i] <== n2bData.out[64 + i]*(1-onChain);
     }
     for (i=0; i<16; i++) {
-        dataAvailabilityBits[nLevels*2+16 + i] <== n2bData.out[144 + i]*(1-onChain);
+        dataAvailabilityBits[nLevels*2 + 16 -1 - i] <== n2bData.out[128 + i]*(1-onChain);
     }
 
 // offChainHash
@@ -135,7 +132,7 @@ template DecodeTx(nLevels) {
     component hash1 = Poseidon(3, 6, 8, 57);
     hash1.inputs[0] <== IDEN3_ROLLUP_TX;
     hash1.inputs[1] <== txData;
-    hash1.inputs[2] <== rqTxHash;
+    hash1.inputs[2] <== rqTxData;
 
     hash1.out ==> offChainHash;
 
diff --git a/circuits/feeSelector.circom b/circuits/feeSelector.circom
index 75f5319a..cd7c2bae 100644
--- a/circuits/feeSelector.circom
+++ b/circuits/feeSelector.circom
@@ -118,7 +118,7 @@ template FeeSelector() {
     signal input coin;
     signal input feePlanCoin[16];
     signal input feePlanFee[16];
-    signal output minFee;
+    signal output operatorsFee;
     signal output countersBase;
 
     component stp[16];
@@ -139,6 +139,6 @@ template FeeSelector() {
         stp[i].feePlanFee <== feePlanFee[i];
     }
 
-    minFee <== stp[15].currentFeeOut;
+    operatorsFee <== stp[15].currentFeeOut;
     countersBase <== stp[15].counterBaseOut * stp[15].isSelectedOut;
 }
diff --git a/circuits/requiredtxverifier.circom b/circuits/requiredtxverifier.circom
index 3e390e12..ded1ab82 100644
--- a/circuits/requiredtxverifier.circom
+++ b/circuits/requiredtxverifier.circom
@@ -11,26 +11,26 @@ RqTxVerifier
                            └──┬─┬─┬──────┘
                               │ │ │
                            ╲  │ │ │
-               TxHash -1    ╲ │ │ │
+               TxData -1    ╲ │ │ │
                ──────────▶   ╲▼ │ │
-               TxHash -2      ╲ │ │
+               TxData -2      ╲ │ │
                ──────────▶     ╲▼ │
-               TxHash -3        ╲ │
+               TxData -3        ╲ │
                ──────────▶       ╲▼
-               TxHash -4          ╲
+               TxData -4          ╲
                ──────────▶         ╲
-               TxHash +3      Mux3  ──────────┐
+               TxData +3      Mux3  ──────────┐
                ──────────▶         ╱          │
-               TxHash +2          ╱           │          ┌────────┐
+               TxData +2          ╱           │          ┌────────┐
                ──────────▶       ╱            │          │        │
-               TxHash +1        ╱             └─────────▶│        │
+               TxData +1        ╱             └─────────▶│        │
                ──────────▶     ╱                         │  ===   │
                    0          ╱                          │        │
                ──────────▶   ╱     ┌────────────────────▶│        │
                             ╱      │                     └────────┘
                            ╱       │
                                    │
-               rqHash              │
+               rqTxData            │
                ────────────────────┘
 
  */
@@ -39,21 +39,21 @@ include "../node_modules/circomlib/circuits/bitify.circom";
 include "../node_modules/circomlib/circuits/mux3.circom";
 
 template RequiredTxVerifier() {
-    signal input pastTxHash[4];
-    signal input futureTxHash[3];
-    signal input rqTxHash;
+    signal input pastTxData[4];
+    signal input futureTxData[3];
+    signal input rqTxData;
     signal input rqTxOffset;
 
     component mux = Mux3();
 
     mux.c[0] <== 0;
-    mux.c[1] <== futureTxHash[0];
-    mux.c[2] <== futureTxHash[1];
-    mux.c[3] <== futureTxHash[2];
-    mux.c[4] <== pastTxHash[3];
-    mux.c[5] <== pastTxHash[2];
-    mux.c[6] <== pastTxHash[1];
-    mux.c[7] <== pastTxHash[0];
+    mux.c[1] <== futureTxData[0];
+    mux.c[2] <== futureTxData[1];
+    mux.c[3] <== futureTxData[2];
+    mux.c[4] <== pastTxData[3];
+    mux.c[5] <== pastTxData[2];
+    mux.c[6] <== pastTxData[1];
+    mux.c[7] <== pastTxData[0];
 
     component n2b = Num2Bits(3);
 
@@ -62,5 +62,5 @@ template RequiredTxVerifier() {
     n2b.out[1] ==> mux.s[1];
     n2b.out[2] ==> mux.s[2];
 
-    mux.out === rqTxHash;
+    mux.out === rqTxData;
 }
diff --git a/circuits/rollup.circom b/circuits/rollup.circom
index bbb6bb2e..c0a53f28 100644
--- a/circuits/rollup.circom
+++ b/circuits/rollup.circom
@@ -18,7 +18,7 @@ template Rollup(nTx, nLevels) {
     signal output countersOut;
 
     signal private input txData[nTx];
-    signal private input rqTxHash[nTx];
+    signal private input rqTxData[nTx];
     signal private input s[nTx];
     signal private input r8x[nTx];
     signal private input r8y[nTx];
@@ -68,7 +68,7 @@ template Rollup(nTx, nLevels) {
     }
 
     var nDataAvailabilityBitsPerTx;
-    nDataAvailabilityBitsPerTx = (nLevels*2+16+16)
+    nDataAvailabilityBitsPerTx = (nLevels*2+16)
     component offChainHasher = Sha256(nDataAvailabilityBitsPerTx*nTx);
 
     component decodeTx[nTx]
@@ -86,12 +86,12 @@ template Rollup(nTx, nLevels) {
             decodeTx[i].previousOnChain <== decodeTx[i-1].onChain;
         }
         decodeTx[i].txData <== txData[i];
-        decodeTx[i].rqTxHash <== rqTxHash[i];
+        decodeTx[i].rqTxData <== rqTxData[i];
         decodeTx[i].loadAmount <== loadAmount[i];
         decodeTx[i].ethAddr <== ethAddr[i];
         decodeTx[i].ax <== ax[i];
         decodeTx[i].ay <== ay[i];
-        for (j=0; j<nLevels*2+32; j++) {
+        for (j=0; j<nLevels*2+16; j++) {
             offChainHasher.in[i*nDataAvailabilityBitsPerTx+j] <== decodeTx[i].dataAvailabilityBits[j];
         }
     }
@@ -110,14 +110,14 @@ template Rollup(nTx, nLevels) {
         Tx[i].amount <== decodeTx[i].amount;
         Tx[i].coin <== decodeTx[i].coin;
         Tx[i].nonce <== decodeTx[i].nonce;
-        Tx[i].maxFee <== decodeTx[i].maxFee;
+        Tx[i].userFee <== decodeTx[i].userFee;
         Tx[i].rqOffset <== decodeTx[i].rqOffset;
         Tx[i].onChain <== decodeTx[i].onChain;
         Tx[i].newAccount <== decodeTx[i].newAccount;
 
         Tx[i].offChainHash <== decodeTx[i].offChainHash;
 
-        Tx[i].rqTxHash <== rqTxHash[i];
+        Tx[i].rqTxData <== rqTxData[i];
         Tx[i].s <== s[i];
         Tx[i].r8x <== r8x[i];
         Tx[i].r8y <== r8y[i];
@@ -171,17 +171,17 @@ template Rollup(nTx, nLevels) {
 
         for (j=0; j<4; j++) {
             if (i-j-1 < -1/2) {
-                Tx[i].pastTxHash[j] <== decodeTx[i-j-1].offChainHash;
+                Tx[i].pastTxData[j] <== txData[i-j-1];
             } else {
-                Tx[i].pastTxHash[j] <== 0;
+                Tx[i].pastTxData[j] <== 0;
             }
         }
 
         for (j=0; j<3; j++) {
             if (i+j+1 < nTx) {
-                Tx[i].futureTxHash[j] <== decodeTx[i+j+1].offChainHash;
+                Tx[i].futureTxData[j] <== txData[i+j+1];
             } else {
-                Tx[i].futureTxHash[j] <== 0;
+                Tx[i].futureTxData[j] <== 0;
             }
         }
     }
diff --git a/circuits/rolluptx.circom b/circuits/rolluptx.circom
index 30e0e60e..cc59cc3e 100644
--- a/circuits/rolluptx.circom
+++ b/circuits/rolluptx.circom
@@ -16,9 +16,9 @@ template RollupTx(nLevels) {
     signal input feePlanCoin[16];
     signal input feePlanFee[16];
 
-    // Past and future TxHashes
-    signal input pastTxHash[4];
-    signal input futureTxHash[3];
+    // Past and future TxDatas
+    signal input pastTxData[4];
+    signal input futureTxData[3];
 
     //TX
 
@@ -27,14 +27,14 @@ template RollupTx(nLevels) {
     signal input amount;
     signal input coin;
     signal input nonce;
-    signal input maxFee;
+    signal input userFee;
     signal input rqOffset;
     signal input onChain;
     signal input newAccount;
 
     signal input offChainHash;
 
-    signal input rqTxHash;
+    signal input rqTxData;
     signal input s;
     signal input r8x;
     signal input r8y;
@@ -109,14 +109,14 @@ template RollupTx(nLevels) {
     component requiredTxVerifier = RequiredTxVerifier();
 
     for (i=0; i<4; i++) {
-        requiredTxVerifier.pastTxHash[i] <== pastTxHash[i];
+        requiredTxVerifier.pastTxData[i] <== pastTxData[i];
     }
 
     for (i=0; i<3; i++) {
-        requiredTxVerifier.futureTxHash[i] <== futureTxHash[i];
+        requiredTxVerifier.futureTxData[i] <== futureTxData[i];
     }
 
-    requiredTxVerifier.rqTxHash <== rqTxHash;
+    requiredTxVerifier.rqTxData <== rqTxData;
     requiredTxVerifier.rqTxOffset <== rqOffset;
 
 // nonceChecker
@@ -184,6 +184,16 @@ template RollupTx(nLevels) {
     s1EthAddr.c[1] <== ethAddr;
     s1EthAddr.s <== states.s1;
 
+    component s1OldKey = Mux1();
+    s1OldKey.c[0] <== states.key1;
+    s1OldKey.c[1] <== oldKey1;
+    s1OldKey.s <== states.s1;
+
+    component s1OldValue = Mux1();
+    s1OldValue.c[0] <== oldSt1Pck.out;
+    s1OldValue.c[1] <== oldValue1;
+    s1OldValue.s <== states.s1;
+
 // s2
 //////////////
 
@@ -198,15 +208,26 @@ template RollupTx(nLevels) {
     s2Ay.s <== states.s2;
 
     component s2Nonce = Mux1();
-    s2Nonce.c[0] <== 0;
-    s2Nonce.c[1] <== nonce2;
+    s2Nonce.c[0] <== nonce2;
+    s2Nonce.c[1] <== 0;
     s2Nonce.s <== states.s2;
 
     component s2EthAddr = Mux1();
-    s2EthAddr.c[0] <== s1EthAddr.out;
-    s2EthAddr.c[1] <== ethAddr2;
+    s2EthAddr.c[0] <== ethAddr2;
+    s2EthAddr.c[1] <== s1EthAddr.out;
     s2EthAddr.s <== states.s2;
 
+    component s2OldKey = Mux1();
+    s2OldKey.c[0] <== states.key2;
+    s2OldKey.c[1] <== oldKey2;
+    s2OldKey.s <== states.s2;
+
+    component s2OldValue = Mux1();
+    s2OldValue.c[0] <== oldSt2Pck.out;
+    s2OldValue.c[1] <== oldValue2;
+    s2OldValue.s <== states.s2;
+
+
 // sigVerifier
 //////////
     component sigVerifier = EdDSAPoseidonVerifier();
@@ -228,12 +249,13 @@ template RollupTx(nLevels) {
     balancesUpdater.oldStAmountSender <== s1Amount.out;
     balancesUpdater.oldStAmountRecieiver <== amount2;
     balancesUpdater.amount <== amount;
-    balancesUpdater.maxFee <== maxFee;
-    balancesUpdater.minFee <== feeSelector.minFee;
+    balancesUpdater.userFee <== userFee;
+    balancesUpdater.operatorsFee <== feeSelector.operatorsFee;
     balancesUpdater.onChain <== onChain;
     balancesUpdater.countersIn <== countersIn;
     balancesUpdater.countersBase <== feeSelector.countersBase;
     balancesUpdater.loadAmount <== loadAmount;
+    balancesUpdater.nop <== states.nop;
 
     balancesUpdater.countersOut ==> countersOut;
 
@@ -264,8 +286,8 @@ template RollupTx(nLevels) {
     for (i=0; i<nLevels; i++) {
         processor1.siblings[i] <== siblings1[i];
     }
-    processor1.oldKey <== oldKey1;
-    processor1.oldValue <== oldValue1;
+    processor1.oldKey <== s1OldKey.out;
+    processor1.oldValue <== s1OldValue.out;
     processor1.isOld0 <== isOld0_1;
     processor1.newKey <== fromIdx;
     processor1.newValue <== newSt1Pck.out;
@@ -284,13 +306,13 @@ template RollupTx(nLevels) {
     component processor2 = SMTProcessor(nLevels) ;
     processor2.oldRoot <== s3.out;
     for (i=0; i<nLevels; i++) {
-        processor2.siblings[i] <== siblings1[i];
+        processor2.siblings[i] <== siblings2[i];
     }
-    processor2.oldKey <== oldKey2;
-    processor2.oldValue <== oldValue2;
+    processor2.oldKey <== s2OldKey.out;
+    processor2.oldValue <== s2OldValue.out;
     processor2.isOld0 <== isOld0_2;
     processor2.newKey <== states.key2;
-    processor2.newValue <== newSt1Pck.out;
+    processor2.newValue <== newSt2Pck.out;
     processor2.fnc[0] <== states.P2_fnc0*balancesUpdater.update2;
     processor2.fnc[1] <== states.P2_fnc1*balancesUpdater.update2;
 
diff --git a/circuits/rolluptxstates.circom b/circuits/rolluptxstates.circom
index e6c43cec..83f3c223 100644
--- a/circuits/rolluptxstates.circom
+++ b/circuits/rolluptxstates.circom
@@ -22,6 +22,7 @@ template RollupTXStates() {
     signal output P2_fnc1;
     signal output isExit;
     signal output verifySignEnabled;
+    signal output nop;
 
     component fromIdxIsZero = IsZero();
     fromIdxIsZero.in <== fromIdx;
@@ -53,7 +54,7 @@ template RollupTXStates() {
     // newAccount MUST be 0 if it an offChain Tx
     (1-onChain)*newAccount === 0;
 
-    s1 <== onChain*isLoadAmount; // The first Processor is initialized
+    s1 <== onChain*isLoadAmount; // The first Processor is in insert
 
     s2 <== isExit*(1-isAmount2) // The second Processor is initialized
 
@@ -79,7 +80,8 @@ template RollupTXStates() {
     mux2.s[1] <== isExit;
     mux2.out ==> key2;
 
-    verifySignEnabled <== (1-onChain)*isFromIdx
+    verifySignEnabled <== (1-onChain)*isFromIdx;
 
+    nop <== fromIdxIsZero.out;
 
 }
diff --git a/circuits/statepacker.circom b/circuits/statepacker.circom
index 978e3361..ac7228c0 100644
--- a/circuits/statepacker.circom
+++ b/circuits/statepacker.circom
@@ -12,13 +12,14 @@ template StatePacker() {
     signal output out;
 
     signal data;
-    data <== amount + coin * (1<<128) + nonce * (1<<142);
-    component hash = Poseidon(4, 6, 8, 57);
+    data <== coin + nonce * (1<<32);
+    component hash = Poseidon(5, 6, 8, 57);
 
     hash.inputs[0] <== data;
-    hash.inputs[1] <== ax;
-    hash.inputs[2] <== ay;
-    hash.inputs[3] <== ethAddr;
+    hash.inputs[1] <== amount;
+    hash.inputs[2] <== ax;
+    hash.inputs[3] <== ay;
+    hash.inputs[4] <== ethAddr;
 
     hash.out ==> out;
 }
diff --git a/js/blockbuilder.js b/js/blockbuilder.js
index 3cce7c70..685504fb 100644
--- a/js/blockbuilder.js
+++ b/js/blockbuilder.js
@@ -1,5 +1,5 @@
 
-const SMT = require("circomlib").SMT.SMT;
+const SMT = require("circomlib").SMT;
 const SMTTmpDb = require("./smttmpdb");
 const utils = require("./utils");
 const assert = require("assert");
@@ -8,19 +8,26 @@ const bigInt = require("snarkjs").bigInt;
 const poseidon = require("circomlib").poseidon;
 
 module.exports = class BlockBuilder {
-    constructor(currentTree, maxNTx, nLevels) {
+    constructor(db, blockNumber, root, maxNTx, nLevels) {
         assert((nLevels % 8) == 0);
+        this.blockNumber = blockNumber;
         this.maxNTx = maxNTx || 4;
         this.nLevels = nLevels;
         this.offChainTxs = [];
         this.onChainTxs = [];
-        this.stateTree = new SMT(new SMTTmpDb(currentTree.db), currentTree.root);
+        this.dbState = new SMTTmpDb(db);
+        this.stateTree = new SMT(this.dbState, root);
+        this.dbExit = new SMTTmpDb(db);
+        this.exitTree = new SMT(this.dbExit, bigInt(0));
+        this.feePlan = [];
+        this.counters = [];
+
         this.input = {
-            oldStRoot: currentTree.root,
+            oldStRoot: this.stateTree.root,
             feePlanCoins: 0,
             feePlanFees: 0,
             txData: [],
-            rqTxHash: [],
+            rqTxData: [],
             s: [],
             r8x: [],
             r8y: [],
@@ -59,12 +66,12 @@ module.exports = class BlockBuilder {
             amount: 0,
             coin: 0,
             nonce: 0,
-            maxFee: 0,
+            userFee: 0,
             rqOffset: 0,
             inChain: 0,
             newAccount: 0
         });
-        this.input.rqTxHash[i]= 0;
+        this.input.rqTxData[i]= 0;
         this.input.s[i]= 0;
         this.input.r8x[i]= 0;
         this.input.r8y[i]= 0;
@@ -87,7 +94,7 @@ module.exports = class BlockBuilder {
         this.input.oldKey1[i]= 0;
         this.input.oldValue1[i]= 0;
 
-        // State 1
+        // State 2
         this.input.ax2[i]= 0;
         this.input.ay2[i]= 0;
         this.input.amount2[i]= 0;
@@ -102,42 +109,125 @@ module.exports = class BlockBuilder {
         this.input.oldValue2[i]= 0;
     }
 
-    async _addOnChainTx(tx) {
+    getOperatorFee(coin) {
+        for (let i=0; i<this.feePlan.length; i++) {
+            if (this.feePlan[i][0] == coin) return utils.float2fix(this.feePlan[1]);
+        }
+        return bigInt[0];
+
+    }
+
+    async _addTx(tx) {
         const i = this.input.txData.length;
 
-        const resFind = await this.stateTree.find(tx.fromIdx);
+        const amountF = utils.fix2float(tx.amount || 0);
+        const amount = utils.float2fix(amountF);
 
-        this.input.txData[i] = utils.buildTxData({
-            fromIdx: tx.fromIdx,
-            toIdx: tx.toIdx || 0,
-            amount: tx.amount || 0,
-            coin: tx.coin,
-            nonce: tx.nonce || 0,
-            maxFee: tx.maxFee  || 0,
-            rqOffset: 0,
-            inChain: 1,
-            newAccount: resFind.found ? 0 : 1
-        });
-        this.input.rqTxHash[i]= 0;
-        this.input.s[i]= 0;
-        this.input.r8x[i]= 0;
-        this.input.r8y[i]= 0;
-        this.input.loadAmount[i]= tx.loadAmount || 0;
-        this.input.ethAddr[i]= bigInt(tx.ethAddress);
-        this.input.ax[i]= bigInt("0x" + tx.ax);
-        this.input.ay[i]= bigInt("0x" + tx.ay);
+        let loadAmount = bigInt(tx.loadAmount || 0);
+        if ((!tx.onChain)&&(loadAmount.greater(bigInt(0)))) {
+            throw new Error("Load ammount must be 0 for offChainTxs");
+        }
 
-        if (resFind.found) {
-            // TODO load onchain
+        let oldState1;
+        let oldState2;
+        let op1 = "NOP";
+        let op2 = "INSERT";
+        let isExit;
+        let newAccount = 0;
+
+        const resFind1 = await this.stateTree.find(tx.fromIdx);
+        if (resFind1.found) {
+            oldState1 = utils.array2state(await this.dbState.get(resFind1.foundValue));
+            op1 = "UPDATE";
         } else {
-            const newValue = utils.hashState({
+            oldState1 = {
+                amount: bigInt(0),
+                coin: tx.coin,
+                nonce: 0,
                 ax: tx.ax,
                 ay: tx.ay,
-                amount: tx.loadAmount,      // TODO: Substract amount, fee
-                nonce: 0,
-                coin: tx.coin,
                 ethAddress: tx.ethAddress
-            });
+            };
+            op1 = "INSERT";
+            newAccount = 1;
+        }
+
+        let resFind2;
+        let resFindExit;
+        if (tx.toIdx) {
+            resFind2 = await this.stateTree.find(tx.toIdx);
+            if (!resFind2.found) {
+                throw new Error("trying to send to a wrong address");
+            }
+            oldState2 = utils.array2state(await this.dbState.get(resFind2.foundValue));
+            isExit = false;
+            op2 = "UPDATE";
+        } else {
+            resFindExit = await this.exitTree.find(tx.toIdx || 0);
+            if (resFindExit.found) {
+                oldState2 = utils.array2state(await this.dbExit.get(resFindExit.foundValue));
+                op2 = "UPDATE";
+            } else {
+                oldState2 = {
+                    amount: bigInt(0),
+                    coin: tx.coin,
+                    nonce: 0,
+                    ax: tx.ax,
+                    ay: tx.ay,
+                    ethAddress: tx.ethAddress
+                };
+                op2 = "INSERT";
+            }
+            isExit = true;
+        }
+
+        let operatorFee;
+        if (tx.onChain) {
+            operatorFee = bigInt(0);
+        } else {
+            operatorFee = this.getOperatorFee(tx.coin);
+        }
+
+        let effectiveAmount = amount;
+        const underFlowOk = (oldState1.amount.add(loadAmount).sub(amount).sub(operatorFee).greaterOrEquals(bigInt(0)));
+        const overflowOk = (oldState2.amount.add(amount).lesser(bigInt(1).shl(128)));
+        const txOk = underFlowOk && overflowOk;
+        if (!txOk) {
+            if (tx.onChain) {
+                effectiveAmount = bigInt(0);
+            } else {
+                let errStr = "Error ";
+                if (!underFlowOk) errStr = "underflow";
+                if (!overflowOk) errStr = "overflow";
+                throw new Error(errStr);
+            }
+        }
+
+        if (effectiveAmount.equals(bigInt(0))) op2="NOP";
+
+        this.input.txData[i] = utils.buildTxData(Object.assign({newAccount: newAccount}, tx));
+        this.input.rqTxData[i]= tx.rqTxData || 0;
+        this.input.s[i]= tx.s || 0;
+        this.input.r8x[i]= tx.r8x || 0;
+        this.input.r8y[i]= tx.r8y || 0;
+        this.input.loadAmount[i]= loadAmount;
+        this.input.ethAddr[i]= bigInt(oldState1.ethAddress);
+        this.input.ax[i]= bigInt("0x" +oldState1.ax);
+        this.input.ay[i]= bigInt("0x" +oldState1.ay);
+
+
+        const newState1 = Object.assign({}, oldState1);
+        newState1.amount = oldState1.amount.add(loadAmount).sub(effectiveAmount).sub(operatorFee);
+        if (!tx.onChain) {
+            newState1.nonce++;
+            this._incCounter(tx.coin);
+        }
+        const newState2 = Object.assign({}, oldState2);
+        newState2.amount = oldState2.amount.add(effectiveAmount);
+
+        if (op1=="INSERT") {
+
+            const newValue = utils.hashState(newState1);
 
             const res = await this.stateTree.insert(tx.fromIdx, newValue);
             let siblings = res.siblings;
@@ -148,24 +238,115 @@ module.exports = class BlockBuilder {
             this.input.ay1[i]= 0x1234;      // It should not matter
             this.input.amount1[i]= 0x1234;  // It should not matter
             this.input.nonce1[i]= 0x1234;   // It should not matter
-            this.input.ethAddr1[i]= this.input.ethAddr[i]; // It should not matter
+            this.input.ethAddr1[i]= this.input.ethAddr[i]; // In the onChain TX this must match
             this.input.siblings1[i] = siblings;
             this.input.isOld0_1[i]= res.isOld0 ? 1 : 0;
             this.input.oldKey1[i]= res.isOld0 ? 0 : res.oldKey;
             this.input.oldValue1[i]= res.isOld0 ? 0 : res.oldValue;
+
+            await this.dbState.multiIns([[newValue, utils.state2array(newState1)]]);
+        } else if (op1 == "UPDATE") {
+            const newValue = utils.hashState(newState1);
+
+            const res = await this.stateTree.update(tx.fromIdx, newValue);
+            let siblings = res.siblings;
+            while (siblings.length<this.nLevels) siblings.push(bigInt(0));
+
+            // State 1
+            this.input.ax1[i]= bigInt("0x" + oldState1.ax);      // It should not matter
+            this.input.ay1[i]= bigInt("0x" + oldState1.ay);      // It should not matter
+            this.input.amount1[i]= oldState1.amount;  // It should not matter
+            this.input.nonce1[i]= oldState1.nonce;   // It should not matter
+            this.input.ethAddr1[i]= bigInt(oldState1.ethAddress); // It should not matter
+
+
+            this.input.siblings1[i] = siblings;
+            this.input.isOld0_1[i]= 0;
+            this.input.oldKey1[i]= 0x1234;      // It should not matter
+            this.input.oldValue1[i]= 0x1234;    // It should not matter
+
+            await this.dbState.multiDel([resFind1.foundValue]);
+            await this.dbState.multiIns([[newValue, utils.state2array(newState1)]]);
         }
 
-        if (tx.amount) {
-            // TODO
-        } else{
+        if (op2=="INSERT") {
+            const newValue = utils.hashState(newState2);
+
+            const res = await this.exitTree.insert(tx.fromIdx, newValue);
+            if (res.found) {
+                throw new Error("Invalid Exit account");
+            }
+            let siblings = res.siblings;
+            while (siblings.length<this.nLevels) siblings.push(bigInt(0));
+
             // State 1
+            this.input.ax2[i]= 0x1234;      // It should not matter
+            this.input.ay2[i]= 0x1234;      // It should not matter
+            this.input.amount2[i]= 0;  // Must be 0 to signal is an insert.
+            this.input.nonce2[i]= 0x1234;   // It should not matter
+            this.input.ethAddr2[i]= this.input.ethAddr[i]; // In the onChain TX this must match
+            this.input.siblings2[i] = siblings;
+            this.input.isOld0_2[i]= res.isOld0 ? 1 : 0;
+            this.input.oldKey2[i]= res.isOld0 ? 0 : res.oldKey;
+            this.input.oldValue2[i]= res.isOld0 ? 0 : res.oldValue;
+
+            await this.dbExit.multiIns([[newValue, utils.state2array(newState2)]]);
+
+        } else if (op2=="UPDATE") {
+            if (isExit) {
+                const newValue = utils.hashState(newState2);
+
+                const res = await this.exitTree.update(tx.fromIdx, newValue);
+                let siblings = res.siblings;
+                while (siblings.length<this.nLevels) siblings.push(bigInt(0));
+
+                // State 2
+                this.input.ax2[i]= bigInt("0x" + oldState2.ax);      // It should not matter
+                this.input.ay2[i]= bigInt("0x" + oldState2.ay);      // It should not matter
+                this.input.amount2[i]= oldState2.amount;  // It should not matter
+                this.input.nonce2[i]= oldState2.nonce;   // It should not matter
+                this.input.ethAddr2[i]= bigInt(oldState2.ethAddress); // It should not matter
+
+
+                this.input.siblings2[i] = siblings;
+                this.input.isOld0_2[i]= 0;
+                this.input.oldKey2[i]= 0x1234;      // It should not matter
+                this.input.oldValue2[i]= 0x1234;    // It should not matter
+
+                await this.dbExit.multiDel([resFindExit.foundValue]);
+                await this.dbExit.multiIns([[newValue, utils.state2array(newState2)]]);
+            } else {
+                const newValue = utils.hashState(newState2);
+
+                const res = await this.stateTree.update(tx.toIdx, newValue);
+                let siblings = res.siblings;
+                while (siblings.length<this.nLevels) siblings.push(bigInt(0));
+
+                // State 2
+                this.input.ax2[i]= bigInt("0x" + oldState2.ax);      // It should not matter
+                this.input.ay2[i]= bigInt("0x" + oldState2.ay);      // It should not matter
+                this.input.amount2[i]= oldState2.amount;  // It should not matter
+                this.input.nonce2[i]= oldState2.nonce;   // It should not matter
+                this.input.ethAddr2[i]= bigInt(oldState2.ethAddress); // It should not matter
+
+
+                this.input.siblings2[i] = siblings;
+                this.input.isOld0_2[i]= 0;
+                this.input.oldKey2[i]= 0x1234;      // It should not matter
+                this.input.oldValue2[i]= 0x1234;    // It should not matter
+
+                await this.dbState.multiDel([resFind2.foundValue]);
+                await this.dbState.multiIns([[newValue, utils.state2array(newState2)]]);
+            }
+        } else if (op2=="NOP") {
+            // State 2
             this.input.ax2[i]= 0;
             this.input.ay2[i]= 0;
             this.input.amount2[i]= 0;
             this.input.nonce2[i]= 0;
             this.input.ethAddr2[i]= 0;
             this.input.siblings2[i] = [];
-            for (let j=0; j<this.nLevels; j++) {
+            for (let j=0; j<8; j++) {
                 this.input.siblings2[i][j]= 0;
             }
             this.input.isOld0_2[i]= 0;
@@ -174,20 +355,31 @@ module.exports = class BlockBuilder {
         }
     }
 
-    _addOffChainTx() {
-
+    _incCounter(coin) {
+        const getIdx = (coin) => {
+            for (let i=0; i<this.feePlan.length; i++) {
+                if (this.feePlan[i][0] == coin) return i;
+            }
+            return -1;
+        };
+        const idx = getIdx(coin);
+        if (idx <0) return;
+        if (this.counters[idx]+1 >= ( (idx < 15) ? (1<<13) : (1<<16) ) ) {
+            throw new Error("Maximum TXs per coin in a block reached");
+        }
+        this.counters[idx]++;
     }
 
     async build() {
         if (this.builded) throw new Error("Block already builded");
         for (let i=0; i<this.offChainTxs.length; i++) {
-            await this._addOffChainTx(this.onChainTxs[i]);
+            await this._addTx(this.offChainTxs[i]);
         }
         for (let i=0; i<this.maxNTx - this.offChainTxs.length - this.onChainTxs.length; i++) {
             this._addNopTx();
         }
         for (let i=0; i<this.onChainTxs.length; i++) {
-            await this._addOnChainTx(this.onChainTxs[i]);
+            await this._addTx(this.onChainTxs[i]);
         }
         this.builded=true;
     }
@@ -204,7 +396,7 @@ module.exports = class BlockBuilder {
 
     getNewExitRoot() {
         if (!this.builded) throw new Error("Block must first be builded");
-        return 0;
+        return this.exitTree.root;
     }
 
     getDataAvailable() {
@@ -213,14 +405,13 @@ module.exports = class BlockBuilder {
         const bytes = [];
         function pushInt(n, size) {
             for (let i=0; i<size; i++) {
-                bytes.push((n >> (i*8))&0xFF);
+                bytes.push((n >> ((size-1-i)*8))&0xFF);
             }
         }
         for (let i=0; i<this.offChainTxs.length; i++) {
             pushInt(this.offChainTxs[i].fromIdx, this.nLevels/8);
             pushInt(this.offChainTxs[i].toIdx, this.nLevels/8);
             pushInt(utils.fix2float(this.offChainTxs[i].amount), 2);
-            pushInt(this.offChainTxs[i].coin, 2);
         }
         return Buffer.from(bytes);
     }
@@ -246,7 +437,7 @@ module.exports = class BlockBuilder {
 
     getOffChainHash() {
         if (!this.builded) throw new Error("Block must first be builded");
-        const txSize = (this.nLevels/8)*2+2+2;
+        const txSize = (this.nLevels/8)*2+2;
         const data = this.getDataAvailable();
         const post = Buffer.alloc((this.maxNTx - (this.offChainTxs.length))*txSize);
 
@@ -262,15 +453,36 @@ module.exports = class BlockBuilder {
 
     getCountersOut() {
         if (!this.builded) throw new Error("Block must first be builded");
-        return 0;
+        let res = bigInt(0);
+        for (let i=0; i<this.counters.length; i++) {
+            res = res.add( bigInt(this.counters[i]).shl(16*i) );
+        }
+        return res;
     }
 
-    createAccount(tx) {
+    addTx(tx) {
         if (this.builded) throw new Error("Block already builded");
         if (this.onChainTxs.length + this.offChainTxs.length >= this.maxNTx) {
             throw Error("Too many TX per block");
         }
-        this.onChainTxs.push(tx);
+        if (tx.onChain) {
+            this.onChainTxs.push(tx);
+        } else {
+            this.offChainTxs.push(tx);
+        }
+    }
+
+    addCoin(coin, fee) {
+        const feeF = utils.fix2float(fee);
+        if (feeF == 0) return;
+        if (this.feePlan.length >= 16) {
+            throw new Error("Maximum 16 coins per block");
+        }
+        if ((this.feePlan.length == 15)&&(coin >= 1<<13)) {
+            throw new Error("Coin 16 muns be less than 2^13");
+        }
+        this.feePlan.push([coin, feeF]);
+        this.counters.push(0);
     }
 
 
diff --git a/js/rollupaccount.js b/js/rollupaccount.js
index 3a107aca..85ede890 100644
--- a/js/rollupaccount.js
+++ b/js/rollupaccount.js
@@ -3,12 +3,20 @@ const ec = new EC("secp256k1");
 const keccak256 = require("js-sha3").keccak256;
 const crypto = require("crypto");
 const babyJub = require("circomlib").babyJub;
+const eddsa = require("circomlib").eddsa;
 const bigInt = require("snarkjs").bigInt;
+const utils = require("./utils");
+const poseidon = require("circomlib").poseidon;
 
 module.exports = class RollupAccount {
     constructor(privateKey) {
         if (privateKey) {
-            this.privateKey = privateKey;
+            if (typeof(privateKey) != "string") {
+                this.privateKey = bigInt(privateKey).toString(16);
+            } else {
+                this.privateKey = privateKey;
+            }
+            while (this.privateKey.length < 64) this.privateKey = "0" + this.privateKey;
         } else {
             this.privateKey = crypto.randomBytes(32).toString("hex");
         }
@@ -40,9 +48,26 @@ module.exports = class RollupAccount {
         // Derive a private key wit a hash
         this.rollupPrvKey = keccak256("ROLLUP" + this.privateKey);
 
-        const bjPubKey = babyJub.mulPointEscalar(babyJub.Base8, bigInt("0x" + this.rollupPrvKey));
+        const bjPubKey = eddsa.prv2pub(this.rollupPrvKey);
 
         this.ax = bjPubKey[0].toString(16);
         this.ay = bjPubKey[1].toString(16);
     }
+
+    signTx(tx) {
+        const IDEN3_ROLLUP_TX = bigInt("1625792389453394788515067275302403776356063435417596283072371667635754651289");
+        const data = utils.buildTxData(tx);
+        const hash = poseidon.createHash(6, 8, 57);
+
+        const h = hash([
+            IDEN3_ROLLUP_TX,
+            data,
+            tx.rqData || 0
+        ]);
+
+        const signature = eddsa.signPoseidon(this.rollupPrvKey, h);
+        tx.r8x = signature.R8[0];
+        tx.r8y = signature.R8[1];
+        tx.s = signature.S;
+    }
 };
diff --git a/js/rollupdb.js b/js/rollupdb.js
new file mode 100644
index 00000000..7dcb3419
--- /dev/null
+++ b/js/rollupdb.js
@@ -0,0 +1,50 @@
+const BlockBuilder = require("./blockbuilder");
+const bigInt = require("snarkjs").bigInt;
+
+class RollupDB {
+
+    constructor(db, lastBlock, stateRoot) {
+        this.db = db;
+        this.lastBlock = lastBlock;
+        this.stateRoot = stateRoot;
+    }
+
+    async buildBlock(maxNTx, nLevels) {
+        return new BlockBuilder(this.db, this.lastBlock+1, this.stateRoot, maxNTx, nLevels);
+    }
+
+    async consolidate(bb) {
+        if (bb.blockNumber != this.lastBlock+1) {
+            throw new Error("Updating the wrong block");
+        }
+        if (!bb.builded) {
+            await bb.build();
+        }
+        const insertsState = Object.keys(bb.dbState.inserts).map(function(key) {
+            return [bigInt(key), bb.dbState.inserts[key]];
+        });
+        const insertsExit = Object.keys(bb.dbExit.inserts).map(function(key) {
+            return [bigInt(key), bb.dbExit.inserts[key]];
+        });
+        await this.db.multiIns([
+            ...insertsState,
+            ...insertsExit,
+            [ bb.blockNumber, [bb.stateTree.root, bb.exitTree.root]],
+            [ 0, this.lastBlock]
+        ]);
+        this.lastBlock = this.blockNumber;
+        this.stateRoot = bb.stateTree.root;
+    }
+}
+
+module.exports = async function(db) {
+    const master = await db.get(0);
+    if (!master) {
+        return new RollupDB(db, 0, bigInt(0));
+    }
+    const block = await db.get(master[0]);
+    if (!block) {
+        throw new Error("Database corrupted");
+    }
+    return new RollupDB(db, master[0], block[0]);
+};
diff --git a/js/utils.js b/js/utils.js
index 80eb787c..e85c25d1 100644
--- a/js/utils.js
+++ b/js/utils.js
@@ -73,31 +73,46 @@ function buildTxData(tx) {
     res = res.add( bigInt(tx.toIdx || 0).shl(64));
     res = res.add( bigInt(fix2float(tx.amount || 0)).shl(128));
     res = res.add( bigInt(tx.coin || 0).shl(144));
-    res = res.add( bigInt(tx.nonce || 0).shl(160));
-    res = res.add( bigInt(fix2float(tx.maxFee || 0)).shl(208));
-    res = res.add( bigInt(tx.rqOffset || 0).shl(224));
-    res = res.add( bigInt(tx.inChain ? 1 : 0).shl(228));
-    res = res.add( bigInt(tx.newAccount ? 1 : 0).shl(229));
+    res = res.add( bigInt(tx.nonce || 0).shl(176));
+    res = res.add( bigInt(fix2float(tx.userFee || 0)).shl(224));
+    res = res.add( bigInt(tx.rqOffset || 0).shl(240));
+    res = res.add( bigInt(tx.onChain ? 1 : 0).shl(243));
+    res = res.add( bigInt(tx.newAccount ? 1 : 0).shl(244));
 
     return res;
 }
 
-function hashState(st) {
-    const hash = poseidon.createHash(6, 8, 57);
-
-    const data = bigInt(st.amount).add(  bigInt(st.coin).shl(128) ).add( bigInt(st.nonce).shl(142) );
-
-    const res = hash([
+function state2array(st) {
+    const data = bigInt(st.coin).add( bigInt(st.nonce).shl(32) );
+    return [
         data,
+        bigInt(st.amount),
         bigInt("0x" + st.ax),
         bigInt("0x" + st.ay),
         bigInt(st.ethAddress),
-    ]);
+    ];
+}
 
-    return res;
+function array2state(a) {
+    return {
+        coin: bigInt(a[0]).and(bigInt(1).shl(32).sub(bigInt(1))).toJSNumber(),
+        nonce: bigInt(a[0]).shr(32).and(bigInt(1).shl(32).sub(bigInt(1))).toJSNumber(),
+        amount: bigInt(a[1]),
+        ax: bigInt(a[2]).toString(16),
+        ay: bigInt(a[3]).toString(16),
+        ethAddress: "0x" + bigInt(a[4]).toString(16),
+    };
+}
+
+function hashState(st) {
+    const hash = poseidon.createHash(6, 8, 57);
+
+    return hash(state2array(st));
 }
 
 module.exports.buildTxData = buildTxData;
 module.exports.fix2float = fix2float;
 module.exports.float2fix = float2fix;
 module.exports.hashState = hashState;
+module.exports.state2array = state2array;
+module.exports.array2state = array2state;
diff --git a/test/circuits/input.json b/test/circuits/input.json
index 5f4e3135..80e79e82 100644
--- a/test/circuits/input.json
+++ b/test/circuits/input.json
@@ -1 +1,240 @@
-{"oldStRoot":"0","feePlanCoins":0,"feePlanFees":0,"txData":["0","0","0","1294077440023230710144016724176942272334582932281947479092973291962369"],"rqTxHash":[0,0,0,0],"s":[0,0,0,0],"r8x":[0,0,0,0],"r8y":[0,0,0,0],"loadAmount":[0,0,0,1000],"ethAddr":[0,0,0,"1116390867936048925210605243246199936148774961419"],"ax":[0,0,0,"2536444495813302334051725399203529611284083085956012556783209998548806902399"],"ay":[0,0,0,"14129099889874404948746412698085340218026543006739588516267964927105356860264"],"ax1":[0,0,0,4660],"ay1":[0,0,0,4660],"amount1":[0,0,0,4660],"nonce1":[0,0,0,4660],"ethAddr1":[0,0,0,"1116390867936048925210605243246199936148774961419"],"siblings1":[[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],["0","0","0","0","0","0","0","0"]],"isOld0_1":[0,0,0,1],"oldKey1":[0,0,0,0],"oldValue1":[0,0,0,0],"ax2":[0,0,0,0],"ay2":[0,0,0,0],"amount2":[0,0,0,0],"nonce2":[0,0,0,0],"ethAddr2":[0,0,0,0],"siblings2":[[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0]],"isOld0_2":[0,0,0,0],"oldKey2":[0,0,0,0],"oldValue2":[0,0,0,0]}
+{
+ "oldStRoot": "0",
+ "feePlanCoins": 0,
+ "feePlanFees": 0,
+ "txData": [
+  "0",
+  "0",
+  "1294077440023230710144016724176942272334582932281947479092973291962369",
+  "431359146674410236714672241732596457699132774224023767129425975443457"
+ ],
+ "rqTxData": [
+  0,
+  0,
+  0,
+  0
+ ],
+ "s": [
+  0,
+  0,
+  0,
+  0
+ ],
+ "r8x": [
+  0,
+  0,
+  0,
+  0
+ ],
+ "r8y": [
+  0,
+  0,
+  0,
+  0
+ ],
+ "loadAmount": [
+  0,
+  0,
+  1000,
+  0
+ ],
+ "ethAddr": [
+  0,
+  0,
+  "564285745605685379469803228198653436451829107432",
+  "564285745605685379469803228198653436451829107432"
+ ],
+ "ax": [
+  0,
+  0,
+  "19978187010499430245869538435991859273974821401831892378333645864391780110865",
+  "19978187010499430245869538435991859273974821401831892378333645864391780110865"
+ ],
+ "ay": [
+  0,
+  0,
+  "8221948295571505153368741349618427496143137236526643398342942827546824861670",
+  "8221948295571505153368741349618427496143137236526643398342942827546824861670"
+ ],
+ "ax1": [
+  0,
+  0,
+  4660,
+  "19978187010499430245869538435991859273974821401831892378333645864391780110865"
+ ],
+ "ay1": [
+  0,
+  0,
+  4660,
+  "8221948295571505153368741349618427496143137236526643398342942827546824861670"
+ ],
+ "amount1": [
+  0,
+  0,
+  4660,
+  "1000"
+ ],
+ "nonce1": [
+  0,
+  0,
+  4660,
+  0
+ ],
+ "ethAddr1": [
+  0,
+  0,
+  "564285745605685379469803228198653436451829107432",
+  "564285745605685379469803228198653436451829107432"
+ ],
+ "siblings1": [
+  [
+   0,
+   0,
+   0,
+   0,
+   0,
+   0,
+   0,
+   0
+  ],
+  [
+   0,
+   0,
+   0,
+   0,
+   0,
+   0,
+   0,
+   0
+  ],
+  [
+   "0",
+   "0",
+   "0",
+   "0",
+   "0",
+   "0",
+   "0",
+   "0"
+  ],
+  [
+   "0",
+   "0",
+   "0",
+   "0",
+   "0",
+   "0",
+   "0",
+   "0"
+  ]
+ ],
+ "isOld0_1": [
+  0,
+  0,
+  1,
+  0
+ ],
+ "oldKey1": [
+  0,
+  0,
+  0,
+  4660
+ ],
+ "oldValue1": [
+  0,
+  0,
+  0,
+  4660
+ ],
+ "ax2": [
+  0,
+  0,
+  0,
+  4660
+ ],
+ "ay2": [
+  0,
+  0,
+  0,
+  4660
+ ],
+ "amount2": [
+  0,
+  0,
+  0,
+  4660
+ ],
+ "nonce2": [
+  0,
+  0,
+  0,
+  4660
+ ],
+ "ethAddr2": [
+  0,
+  0,
+  0,
+  "564285745605685379469803228198653436451829107432"
+ ],
+ "siblings2": [
+  [
+   0,
+   0,
+   0,
+   0,
+   0,
+   0,
+   0,
+   0
+  ],
+  [
+   0,
+   0,
+   0,
+   0,
+   0,
+   0,
+   0,
+   0
+  ],
+  [
+   0,
+   0,
+   0,
+   0,
+   0,
+   0,
+   0,
+   0
+  ],
+  [
+   "0",
+   "0",
+   "0",
+   "0",
+   "0",
+   "0",
+   "0",
+   "0"
+  ]
+ ],
+ "isOld0_2": [
+  0,
+  0,
+  0,
+  1
+ ],
+ "oldKey2": [
+  0,
+  0,
+  0,
+  0
+ ],
+ "oldValue2": [
+  0,
+  0,
+  0,
+  0
+ ]
+}
+
diff --git a/test/rollup_circuit.js b/test/rollup_circuit.js
index 9f011b01..a92e972c 100644
--- a/test/rollup_circuit.js
+++ b/test/rollup_circuit.js
@@ -2,21 +2,28 @@ const chai = require("chai");
 const path = require("path");
 const snarkjs = require("snarkjs");
 const compiler = require("circom");
-const utils = require("../js/utils");
 const bigInt = require("snarkjs").bigInt;
 const SMT = require("circomlib").SMT;
-const BlockBuilder = require("../js/blockbuilder");
+const SMTMemDB = require("circomlib").SMTMemDB;
 const fs = require("fs");
 const RollupAccount = require("../js/rollupaccount");
+const RollupDB = require("../js/rollupdb");
 
 const assert = chai.assert;
 
 function checkBlock(circuit, w, bb) {
     const newStateRoot = w[circuit.getSignalIdx("main.newStRoot")];
-    assert(newStateRoot.equals(bb.getNewStateRoot()));
+/*    console.log(newStateRoot.toString());
+    const v=bb.getNewStateRoot();
+    console.log(v);
+*/    assert(newStateRoot.equals(bb.getNewStateRoot()));
+
 
     const newExitRoot = w[circuit.getSignalIdx("main.newExitRoot")];
-    assert(newExitRoot.equals(bb.getNewExitRoot()));
+/*    console.log(newExitRoot.toString());
+    const v2=bb.getNewExitRoot();
+    console.log(v2);
+*/    assert(newExitRoot.equals(bb.getNewExitRoot()));
 
     const onChainHash = w[circuit.getSignalIdx("main.onChainHash")];
     assert(onChainHash.equals(bb.getOnChainHash()));
@@ -34,47 +41,234 @@ describe("Rollup run 4 null TX", function () {
     this.timeout(100000);
 
     before( async() => {
-        // const cirDef = await compiler(path.join(__dirname, "circuits", "rollup_test.circom"), {reduceConstraints:false});
-        const cirDef = JSON.parse(fs.readFileSync(path.join(__dirname, "circuits", "circuit.json"), "utf8"));
+        const cirDef = await compiler(path.join(__dirname, "circuits", "rollup_test.circom"), {reduceConstraints:false});
+        // const cirDef = JSON.parse(fs.readFileSync(path.join(__dirname, "circuits", "circuit.json"), "utf8"));
         circuit = new snarkjs.Circuit(cirDef);
         console.log("NConstrains Rollup: " + circuit.nConstraints);
     });
-
     it("Should create 4 empty TXs", async () => {
 
         // Start a new state
-        const state = await SMT.newMemEmptyTrie();
-        const bb = new BlockBuilder(state, 4, 8);
+        const db = new SMTMemDB();
+        const rollupDB = await RollupDB(db);
+        const bb = await rollupDB.buildBlock(4, 8);
+
+        await bb.build();
+        const input = bb.getInput();
+
+        const w = circuit.calculateWitness(input, {logTrigger:false, logOutput: false, logSet: false});
+
+        checkBlock(circuit, w, bb);
+    });
+    it("Should create 1 deposit onchain TXs", async () => {
+
+        // Start a new state
+        const db = new SMTMemDB();
+        const rollupDB = await RollupDB(db);
+        const bb = await rollupDB.buildBlock(4, 8);
+
+        const account1 = new RollupAccount(1);
+
+        bb.addTx({
+            fromIdx: 1,
+            loadAmount: 1000,
+            coin: 0,
+            ax: account1.ax,
+            ay: account1.ay,
+            ethAddress: account1.ethAddress,
+            onChain: true
+        });
+
+        await bb.build();
+        const input = bb.getInput();
+
+        const w = circuit.calculateWitness(input, {logTrigger:false, logOutput: false, logSet: false});
+
+        checkBlock(circuit, w, bb);
+    });
+    it("Should create 1 deposit onchain TXs and 1 exit onchain TX", async () => {
+
+        // Start a new state
+        const db = new SMTMemDB();
+        const rollupDB = await RollupDB(db);
+        const bb = await rollupDB.buildBlock(4, 8);
+
+        const account1 = new RollupAccount(1);
+
+        bb.addTx({
+            fromIdx: 1,
+            loadAmount: 1000,
+            coin: 0,
+            ax: account1.ax,
+            ay: account1.ay,
+            ethAddress: account1.ethAddress,
+            onChain: true
+        });
+
+        bb.addTx({
+            fromIdx: 1,
+            toIdx: 0,
+            loadAmount: 0,
+            coin: 0,
+            ax: account1.ax,
+            ay: account1.ay,
+            ethAddress: account1.ethAddress,
+            amount: 1000,
+            onChain: true
+        });
 
         await bb.build();
         const input = bb.getInput();
 
+//        console.log(JSON.stringify(snarkjs.stringifyBigInts(input), null, 1));
+
         const w = circuit.calculateWitness(input, {logTrigger:false, logOutput: false, logSet: false});
 
         checkBlock(circuit, w, bb);
     });
-    it("Should create 1 onChain TXs", async () => {
+    it("Should create 2 deposits and then a normal offchain transfer", async () => {
 
         // Start a new state
-        const state = await SMT.newMemEmptyTrie();
-        const bb = new BlockBuilder(state, 4, 8);
+        const db = new SMTMemDB();
+        const rollupDB = await RollupDB(db);
+        const bb = await rollupDB.buildBlock(4, 8);
 
-        const account1 = new RollupAccount();
+        const account1 = new RollupAccount(1);
+        const account2 = new RollupAccount(2);
 
-        bb.createAccount({
+        bb.addTx({
             fromIdx: 1,
             loadAmount: 1000,
             coin: 0,
             ax: account1.ax,
             ay: account1.ay,
-            ethAddress: account1.ethAddress
+            ethAddress: account1.ethAddress,
+            onChain: true
+        });
+
+        bb.addTx({
+            fromIdx: 2,
+            loadAmount: 2000,
+            coin: 0,
+            ax: account2.ax,
+            ay: account2.ay,
+            ethAddress: account2.ethAddress,
+            onChain: true
         });
 
         await bb.build();
         const input = bb.getInput();
 
         const w = circuit.calculateWitness(input, {logTrigger:false, logOutput: false, logSet: false});
+        checkBlock(circuit, w, bb);
+
+        await rollupDB.consolidate(bb);
+
+        const bb2 = await rollupDB.buildBlock(4, 8);
+
+        const tx = {
+            fromIdx: 1,
+            toIdx: 2,
+            coin: 0,
+            amount: 50,
+            nonce: 0,
+            userFee: 10
+        };
+        account1.signTx(tx);
+        bb2.addTx(tx);
+
+        bb2.addCoin(0, 5);
+
+        await bb2.build();
+        const input2 = bb2.getInput();
+
+        const w2 = circuit.calculateWitness(input2, {logTrigger:false, logOutput: false, logSet: false});
+        checkBlock(circuit, w2, bb2);
+    });
+    it("Should check big amounts", async () => {
+
+        // Start a new state
+        const db = new SMTMemDB();
+        const rollupDB = await RollupDB(db);
+        const bb = await rollupDB.buildBlock(4, 8);
+
+        const account1 = new RollupAccount(1);
+        const account2 = new RollupAccount(2);
+
+        bb.addTx({
+            fromIdx: 1,
+            loadAmount: bigInt("1000000000000000000000"),
+            coin: 0,
+            ax: account1.ax,
+            ay: account1.ay,
+            ethAddress: account1.ethAddress,
+            onChain: true
+        });
+
+        bb.addTx({
+            fromIdx: 2,
+            loadAmount: bigInt("2000000000000000000000"),
+            coin: 0,
+            ax: account2.ax,
+            ay: account2.ay,
+            ethAddress: account2.ethAddress,
+            onChain: true
+        });
+
+        await bb.build();
+        const input = bb.getInput();
 
+        const w = circuit.calculateWitness(input, {logTrigger:false, logOutput: false, logSet: false});
         checkBlock(circuit, w, bb);
+
+        await rollupDB.consolidate(bb);
+
+        const bb2 = await rollupDB.buildBlock(4, 8);
+
+        const tx = {
+            fromIdx: 1,
+            toIdx: 2,
+            coin: 0,
+            amount: bigInt("1000000000000000000"),
+            nonce: 0,
+            userFee: bigInt("2000000000000")
+        };
+        account1.signTx(tx);
+        bb2.addTx(tx);
+
+        bb2.addCoin(0, 5);
+
+        await bb2.build();
+        const input2 = bb2.getInput();
+
+        const w2 = circuit.calculateWitness(input2, {logTrigger:false, logOutput: false, logSet: false});
+        checkBlock(circuit, w2, bb2);
+    });
+    it("Should check underflow onchain", async () => {
+    });
+    it("Should check underflow offchain", async () => {
     });
+    it("Should check offchain with loadAmount", async () => {
+    });
+    it("Should check onchain transfer", async () => {
+    });
+    it("Should check onchain deposit existing", async () => {
+    });
+    it("Should check combined deposit transfer", async () => {
+    });
+    it("Should check combined deposit exit", async () => {
+    });
+    it("Should check offchain with invalid fee", async () => {
+    });
+    it("Should check offchain with invalid nonce", async () => {
+    });
+    it("Should check offchain with invalid signature", async () => {
+    });
+    it("Should check offchain with not defined coin", async () => {
+    });
+    it("Should check offchain with double defined coin", async () => {
+    });
+    it("Should check block with invalid order", async () => {
+    });
+
 });