From 346824464e69b6aad03d36b8fc7e8a8bb9ec4e4f Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Mon, 24 Jun 2019 15:48:06 -0400
Subject: [PATCH 01/24] sharingExtension

---
 demos/multipleshares/README.md        |  67 ++++
 demos/multipleshares/client.html      |  33 ++
 demos/multipleshares/client.js        |  66 ++++
 demos/multipleshares/mpc.js           |  44 +++
 demos/multipleshares/party.js         |  43 +++
 demos/multipleshares/server.js        |  19 ++
 demos/multipleshares/test.js          | 131 +++++++
 lib/ext/jiff-client-multipleshares.js | 468 ++++++++++++++++++++++++++
 lib/jiff-client.js                    |   3 +-
 9 files changed, 872 insertions(+), 2 deletions(-)
 create mode 100644 demos/multipleshares/README.md
 create mode 100644 demos/multipleshares/client.html
 create mode 100644 demos/multipleshares/client.js
 create mode 100644 demos/multipleshares/mpc.js
 create mode 100644 demos/multipleshares/party.js
 create mode 100644 demos/multipleshares/server.js
 create mode 100644 demos/multipleshares/test.js
 create mode 100644 lib/ext/jiff-client-multipleshares.js

diff --git a/demos/multipleshares/README.md b/demos/multipleshares/README.md
new file mode 100644
index 000000000..6496c52ac
--- /dev/null
+++ b/demos/multipleshares/README.md
@@ -0,0 +1,67 @@
+# Sum Demo
+
+Description and guide for computing sum of inputs with secure MPC.
+
+## Secure summation protocol 
+
+The implementation of the following protocol may be found in jiff/demos/sum/mpc.js lines 23 through 36.
+
+Input: arbitrary number of parties P1,...Pn with inputs x1,...xn
+
+Each party Pi does the following:
+    - secret shares their input xi to all other parties
+    - iteratively uses secret addition protocol to add all of the shares they received together to get a total sum
+    - reconstructs output sum in final opening step
+
+## Note on the code
+
+The compute function in mpc.js executes once for every single party. In line 29 of *mpc.js*, the parties' shares are 
+created. It is important to note that the variable created in that line, *shares*, is not just the secret shares belonging
+to a single parties' inputs but rather includes all shares that that party has received. The *for* loop in line 31 of *mpc.js* loops
+ through a single party's shares of all of those parties' inputs.
+ 
+Note also that the parties have to iteratively use secret addition instead of doing a single sum of their shares of x1,...,xn
+because in JIFF the secret addition protocol is a binary operation. I.e. if you have shares a, b, and c that you want to
+add, then you can't do
+```
+var output = a.sadd(b,c);
+```
+but instead have to do 
+```
+var d = a.sadd(b);
+var output = d.sadd(c);
+```
+ 
+## Legal inputs
+
+This instantiation of summation only supports positive integer inputs. For an implementation that supports fixed-point 
+numbers, see the fixedpoint-sum demo. 
+
+## Running Demo
+1. Running a server:
+    ```shell
+    node demos/sum/server.js
+    ```
+
+2. Either open browser based parties by going to *http://localhost:8080/demos/sum/client.html* in the browser, or a node.js party by running 
+    ```shell
+    node demos/sum/party.js <input> [<party count> [<computation_id> [<party id>]]]]'
+    ```
+
+3. Running tests: run the following. Note that you *do not* need to have the server running when running the tests; they run the server on their own.
+    ```shell
+    npm run-script test-demo -- demos/sum/test.js
+    ```
+## File structure
+The demo consists of the following parts:
+1. Server script: *server.js*
+2. Web Based Party: Made from the following files:
+    * *client.html*: UI for the browser.
+    * *client.js*: Handlers for UI buttons and input validations.
+3. Node.js-Based Party: 
+    * *party.js*: Main entry point. Parses input from the command line and initializes the computation.
+4. The MPC protocol: Implemented in *mpc.js*. This file is used in both the browser and node.js versions of the demo.
+5. test.js: mocha unit tests.
+6. Documentation:
+    * This *README.md* file.
+
diff --git a/demos/multipleshares/client.html b/demos/multipleshares/client.html
new file mode 100644
index 000000000..d38051083
--- /dev/null
+++ b/demos/multipleshares/client.html
@@ -0,0 +1,33 @@
+<!-- Basic UI for running the demo in the browser -->
+
+<html>
+  <head>
+    <title>Sum integers under Multiple Shares MPC</title>
+    <style>
+      .error {
+        color: #FF0000;
+      }
+    </style>
+    <script src="https://code.jquery.com/jquery-1.11.1.js"></script>
+    <script src="/socket.io/socket.io.js"></script>
+    <script src="/lib/sodium.js"></script>
+    <script src="/lib/jiff-client.js"></script>
+    <script src="/lib/ext/jiff-client-multipleshares.js"></script>
+
+    <!-- Contains UI Handlers and Input Checks -->
+    <script type="text/javascript" src="./client.js"></script>
+
+    <!-- Contains the MPC implementation -->
+    <script type="text/javascript" src="./mpc.js"></script>
+  </head>
+  <body>
+    <h1>Connect JIFF</h1>
+    <label for="computation_id">Computation ID</label><input id="computation_id" value="test"></input><br/><br/>
+    <label for="count">Party Count<label> <input id="count" pattern="[0-9]*" value="2"> &nbsp; <button id="connectButton" onclick="connect();">Connect</button>
+    <br/><br/>
+    <hr/>
+    <h1>Sum Numbers under Multiple Shares MPC</h1>
+    <label for="number">Input Number (between 0 and 100)</label> <input id="number" pattern="[0-9]+"> &nbsp; <button onclick="submit();" disabled="disabled" id="button">Sum</button><br/>
+    <div id="output"></div>
+  </body>
+</html>
diff --git a/demos/multipleshares/client.js b/demos/multipleshares/client.js
new file mode 100644
index 000000000..abbca673c
--- /dev/null
+++ b/demos/multipleshares/client.js
@@ -0,0 +1,66 @@
+/**
+ * Do not modify this file unless you have to.
+ * This file has UI handlers.
+ */
+
+// eslint-disable-next-line no-unused-vars
+function connect() {
+  $('#connectButton').prop('disabled', true);
+  var computation_id = $('#computation_id').val();
+  var party_count = parseInt($('#count').val());
+  //var receiver_ratios =
+
+  if (isNaN(party_count)) {
+    $('#output').append("<p class='error'>Party count must be a valid number!</p>");
+    $('#connectButton').prop('disabled', false);
+  } else {
+    var options = { party_count: party_count};
+    options.onError = function (error) {
+      $('#output').append("<p class='error'>"+error+'</p>');
+    };
+    options.onConnect = function () {
+      $('#button').attr('disabled', false); $('#output').append('<p>All parties Connected!</p>');
+    };
+
+    var hostname = window.location.hostname.trim();
+    var port = window.location.port;
+    if (port == null || port === '') {
+      port = '80';
+    }
+    if (!(hostname.startsWith('http://') || hostname.startsWith('https://'))) {
+      hostname = 'http://' + hostname;
+    }
+    if (hostname.endsWith('/')) {
+      hostname = hostname.substring(0, hostname.length-1);
+    }
+    if (hostname.indexOf(':') > -1 && hostname.lastIndexOf(':') > hostname.indexOf(':')) {
+      hostname = hostname.substring(0, hostname.lastIndexOf(':'));
+    }
+
+    hostname = hostname + ':' + port;
+    // eslint-disable-next-line no-undef
+    mpc.connect(hostname, computation_id, options);
+  }
+}
+
+// eslint-disable-next-line no-unused-vars
+function submit() {
+  var input = parseInt($('#number').val());
+
+  if (isNaN(input)) {
+    $('#output').append("<p class='error'>Input a valid number!</p>");
+  } else if (100 < input || input < 0 || input !== Math.floor(input)) {
+    $('#output').append("<p class='error'>Input a WHOLE number between 0 and 100!</p>");
+  } else {
+    $('#button').attr('disabled', true);
+    $('#output').append('<p>Starting...</p>');
+    // eslint-disable-next-line no-undef
+    var promise = mpc.compute(input);
+    promise.then(handleResult);
+  }
+}
+
+function handleResult(result) {
+  $('#output').append('<p>Result is: ' + result + '</p>');
+  $('#button').attr('disabled', false);
+}
diff --git a/demos/multipleshares/mpc.js b/demos/multipleshares/mpc.js
new file mode 100644
index 000000000..c6c7166b6
--- /dev/null
+++ b/demos/multipleshares/mpc.js
@@ -0,0 +1,44 @@
+(function (exports, node) {
+  var saved_instance;
+
+  /**
+   * Connect to the server and initialize the jiff instance
+   */
+  exports.connect = function (hostname, computation_id, options) {
+    var opt = Object.assign({}, options);
+    opt.warn = false;
+    if (node) {
+      // eslint-disable-next-line no-undef
+      jiff = require('../../lib/jiff-client');
+      jiff_fixedpoint = require('../../lib/ext/jiff-client-fixedpoint');
+      jiff_multipleshares = require('../../lib/ext/jiff-client-multipleshares');
+    }
+
+    opt.autoConnect = false;
+    // eslint-disable-next-line no-undef
+    saved_instance = jiff.make_jiff(hostname, computation_id, opt);
+    saved_instance.apply_extension(jiff_multipleshares, opt);
+    saved_instance.connect();
+    return saved_instance;
+  };
+
+  /**
+   * The MPC computation
+   */
+  exports.compute = function (input, jiff_instance) {
+    if (jiff_instance == null) {
+      jiff_instance = saved_instance;
+    }
+
+    // The MPC implementation should go *HERE*
+    var shares = jiff_instance.share(input);
+    var sum = shares[1];
+    console.log(shares);
+    //for (var i = 2; i <= jiff_instance.party_count; i++) {
+    //  sum = sum.sadd(shares[i]);
+    //}
+
+    // Return a promise to the final output(s)
+    //return jiff_instance.open(sum);
+  };
+}((typeof exports === 'undefined' ? this.mpc = {} : exports), typeof exports !== 'undefined'));
diff --git a/demos/multipleshares/party.js b/demos/multipleshares/party.js
new file mode 100644
index 000000000..a1d8f7189
--- /dev/null
+++ b/demos/multipleshares/party.js
@@ -0,0 +1,43 @@
+/**
+ * Do not change this unless you have to.
+ * This code parses input command line arguments,
+ * and calls the appropriate initialization and MPC protocol from ./mpc.js
+ */
+
+console.log('Command line arguments: <input> [<party count> [<computation_id> [<party id>]]]]');
+
+var mpc = require('./mpc');
+
+// Read Command line arguments
+var input = parseInt(process.argv[2], 10);
+
+var party_count = process.argv[3];
+if (party_count == null) {
+  party_count = 2;
+} else {
+  party_count = parseInt(party_count);
+}
+
+var computation_id = process.argv[4];
+if (computation_id == null) {
+  computation_id = 'test';
+}
+
+var party_id = process.argv[5];
+if (party_id != null) {
+  party_id = parseInt(party_id, 10);
+}
+
+// JIFF options
+var options = {party_count: party_count, party_id: party_id};
+options.onConnect = function (jiff_instance) {
+  var promise = mpc.compute(input);
+
+  promise.then(function (v) {
+    console.log(v);
+    jiff_instance.disconnect(true);
+  });
+};
+
+// Connect
+mpc.connect('http://localhost:8080', computation_id, options);
diff --git a/demos/multipleshares/server.js b/demos/multipleshares/server.js
new file mode 100644
index 000000000..d0a192762
--- /dev/null
+++ b/demos/multipleshares/server.js
@@ -0,0 +1,19 @@
+var express = require('express');
+var app = express();
+var http = require('http').Server(app);
+var base_instance = require('../../lib/jiff-server').make_jiff(http, { logs:true });
+
+//Serve static files
+//Configure App
+app.use('/demos', express.static('demos'));
+app.use('/lib', express.static('lib'));
+app.use('/lib/ext', express.static('lib/ext'));
+
+// Serve static files.
+http.listen(8080, function () {
+  console.log('listening on *:8080');
+});
+
+console.log('Direct your browser to *:8080/demos/multipleshares/client.html.');
+console.log('To run a node.js based party: node demos/multipleshares/party <input>');
+console.log();
diff --git a/demos/multipleshares/test.js b/demos/multipleshares/test.js
new file mode 100644
index 000000000..5fef4b897
--- /dev/null
+++ b/demos/multipleshares/test.js
@@ -0,0 +1,131 @@
+// Chai
+var assert = require('chai').assert;
+
+var mpc = require('./mpc.js');
+
+// Generic Testing Parameters
+var showProgress = false;
+var party_count = 3;
+var parallelismDegree = 100; // Max number of test cases running in parallel
+var n = 1000;
+var Zp = null;
+
+// Parameters specific to this demo
+var maxValue = 1000;
+
+
+/**
+ * CHANGE THIS: Generate inputs for your tests
+ * Should return an object with this format:
+ * {
+ *   'party_id': [ 'test1_input', 'test2_input', ...]
+ * }
+ */
+function generateInputs(party_count) {
+  var inputs = {};
+  var i;
+
+  for (i = 0; i < party_count; i++) {
+    inputs[i+1] = [];
+  }
+
+  for (i = 0; i < party_count; i++) {
+    for (var j = 0; j < n; j++) {
+      inputs[i+1].push(Math.floor((Math.random() * maxValue)));
+    }
+  }
+  return inputs;
+}
+
+/**
+ * CHANGE THIS: Compute the expected results not in MPC
+ * @param {object} inputs - same format as generateInputs output.
+ * Should return a single array with the expected result for every test in order
+ *   [ 'test1_output', 'test2_output', ... ]
+ */
+function computeResults(inputs) {
+  var results = [];
+
+  for (var j = 0; j < n; j++) {
+    var sum = 0;
+    for (var i = 1; i <= party_count; i++) {
+      sum += inputs[i][j];
+    }
+    results.push(sum);
+  }
+  return results;
+}
+
+/**
+ * Do not change unless you have to.
+ */
+// eslint-disable-next-line no-undef
+describe('Test', function () {
+  this.timeout(0); // Remove timeout
+
+  // eslint-disable-next-line no-undef
+  it('Exhaustive', function (done) {
+    var count = 0;
+
+    var inputs = generateInputs(party_count);
+    var realResults = computeResults(inputs);
+
+    var onConnect = function (jiff_instance) {
+      var partyInputs = inputs[jiff_instance.id];
+
+      var testResults = [];
+      (function one_test_case(j) {
+        if (jiff_instance.id === 1 && showProgress) {
+          console.log('\tStart ', j > partyInputs.length ? partyInputs.length : j, '/', partyInputs.length);
+        }
+
+        if (j < partyInputs.length) {
+          var promises = [];
+          for (var t = 0; t < parallelismDegree && (j + t) < partyInputs.length; t++) {
+            promises.push(mpc.compute(partyInputs[j + t], jiff_instance));
+          }
+
+          Promise.all(promises).then(function (parallelResults) {
+            for (var t = 0; t < parallelResults.length; t++) {
+              testResults.push(parallelResults[t]);
+            }
+
+            one_test_case(j + parallelismDegree);
+          });
+
+          return;
+        }
+
+        // If we reached here, it means we are done
+        count++;
+        for (var i = 0; i < testResults.length; i++) {
+          // construct debugging message
+          var ithInputs = inputs[1][i] + '';
+          for (var p = 2; p <= party_count; p++) {
+            ithInputs += ',' + inputs[p][i];
+          }
+          var msg = 'Party: ' + jiff_instance.id + '. inputs: [' + ithInputs + ']';
+
+          // assert results are accurate
+          try {
+            assert.deepEqual(testResults[i].toString(), realResults[i].toString(), msg);
+          } catch (assertionError) {
+            done(assertionError);
+            done = function () {
+            };
+          }
+        }
+
+        jiff_instance.disconnect(true);
+        if (count === party_count) {
+          done();
+        }
+      })(0);
+    };
+
+    var options = { party_count: party_count, onError: console.log, onConnect: onConnect, Zp: Zp };
+    for (var i = 0; i < party_count; i++) {
+      mpc.connect('http://localhost:8080', 'mocha-test', options);
+    }
+  });
+});
\ No newline at end of file
diff --git a/lib/ext/jiff-client-multipleshares.js b/lib/ext/jiff-client-multipleshares.js
new file mode 100644
index 000000000..905e9f7ae
--- /dev/null
+++ b/lib/ext/jiff-client-multipleshares.js
@@ -0,0 +1,468 @@
+/**
+ * @namespace jiff_fixedpoint
+ * @version 1.0
+ */
+(function (exports, node) {
+  /**
+   * The name of this extension: 'multipleshares'
+   * @type {string}
+   * @memberOf jiff_multipleshares
+   */
+  exports.name = 'multipleshares';
+
+  function createMultipleSharesSecretShare(jiff, share, share_helpers) {
+    share.legacy = {};
+    var internals = ['cadd', 'csub', 'cmult',
+      'sadd', 'ssub', 'smult', 'smult_bgw',
+      'cdivfac', 'cdiv', 'sdiv', 'smod',
+      'cxor_bit', 'sxor_bit', 'cor_bit', 'sor_bit', 'not',
+      'slt', 'slteq', 'sgt', 'sgteq', 'seq', 'sneq',
+      'clt', 'clteq', 'cgt', 'cgteq', 'ceq', 'cneq',
+      'lt_halfprime', 'if_else' ];
+    for (var i = 0; i < internals.length; i++) {
+      var key = internals[i];
+      share.legacy[key] = share[key];
+    }
+    return share;
+  }
+
+  function make_jiff(base_instance, options) {
+    var jiff = base_instance;
+
+    // Parse options
+    if (options == null) {
+      options = {};
+    }
+
+    old_open = jiff.open;
+    jiff.open = function(share, parties, op_ids) {
+      console.log(share, typeof(share.value));
+      if (typeof(share.value) === 'number') {
+        old_open(share, parties, op_ids);
+      } else {
+        var i;
+
+        if (!(share.jiff === jiff)) {
+          throw 'share does not belong to given instance';
+        }
+
+        // Default values
+        if (parties == null || parties === []) {
+          parties = [];
+          for (i = 1; i <= jiff.party_count; i++) {
+            parties.push(i);
+          }
+        } else {
+          parties.sort();
+        }
+
+        // If not a receiver nor holder, do nothing
+        if (share.holders.indexOf(jiff.id) === -1 && parties.indexOf(jiff.id) === -1) {
+          return null;
+        }
+
+        // Compute operation ids (one for each party that will receive a result
+        if (op_ids == null) {
+          op_ids = {};
+        }
+
+        if (typeof (op_ids) === 'string' || typeof (op_ids) === 'number') {
+          var tmp = {};
+          for (i = 0; i < parties.length; i++) {
+            tmp[parties[i]] = op_ids;
+          }
+          op_ids = tmp;
+        } else {
+          var holders_label = share.holders.join(',');
+          for (i = 0; i < parties.length; i++) {
+            if (op_ids[parties[i]] == null) {
+              op_ids[parties[i]] = jiff.counters.gen_open_id(parties[i], holders_label);
+            }
+          }
+        }
+
+        // Party is a holder
+        if (share.holders.indexOf(jiff.id) > -1) {
+          // Call hook
+          share = jiff.execute_array_hooks('beforeOpen', [jiff, share, parties], 1);
+
+          // refresh/reshare, so that the original share remains secret, instead
+          // a new share is sent/open without changing the actual value.
+          share = share.refresh('refresh:' + op_ids[parties[0]]);
+
+          // The given share has been computed, share it to all parties
+          if (share.ready) {
+            jiff_broadcast(jiff, share, parties, op_ids);
+          } else {
+            jiff.counters.pending_opens++;
+            // Share is not ready, setup sharing as a callback to its promise
+            share.promise.then(function () {
+              jiff.counters.pending_opens--;
+              jiff_broadcast(jiff, share, parties, op_ids);
+            }, share.error);
+          }
+        }
+
+        // Party is a receiver
+        if (parties.indexOf(jiff.id) > -1) {
+          var shares = []; // this will store received shares
+          var numberofshares = 0;
+          var final_deferred = new Deferred(); // will be resolved when the final value is reconstructed
+          var final_promise = final_deferred.promise;
+          for (i = 0; i < share.holders.length; i++) {
+            var p_id = share.holders[i];
+
+            // Setup a deferred for receiving a share from party p_id
+            if (jiff.deferreds[op_ids[jiff.id]] == null) {
+              jiff.deferreds[op_ids[jiff.id]] = {};
+            }
+            if (jiff.deferreds[op_ids[jiff.id]][p_id] == null) {
+              jiff.deferreds[op_ids[jiff.id]][p_id] = new Deferred();
+            }
+
+            // Clean up deferred when fulfilled
+            var promise = jiff.deferreds[op_ids[jiff.id]][p_id].promise;
+
+            // destroy deferred when done
+            (function (promise, p_id) { // p_id is modified in a for loop, must do this to avoid scoping issues.
+              promise.then(function (received_share) {
+                jiff.deferreds[op_ids[jiff.id]][p_id] = null;
+                shares.push(received_share);
+                numberofshares += received_share['share'].length;
+
+                // Too few shares, nothing to do.
+                if (numberofshares < share.threshold) {
+                  return;
+                }
+
+                // Enough shares to reconstruct.
+                // If did not already reconstruct, do it.
+                if (final_deferred != null) {
+                  var recons_secret = jiff.hooks.reconstructShare(jiff, shares);
+                  recons_secret = jiff.execute_array_hooks('afterReconstructShare', [jiff, recons_secret], 1);
+
+                  final_deferred.resolve(recons_secret);
+                  final_deferred = null;
+                }
+
+                // If all shares were received, clean up.
+                if (shares.length === share.holders.length) {
+                  shares = null;
+                  jiff.deferreds[op_ids[jiff.id]] = null;
+                }
+              });
+            })(promise, p_id);
+          }
+
+          return final_promise;
+        }
+
+        return null;
+      }
+    }
+
+    function receive_open(jiff, json_msg) {
+      // Decrypt share
+      if (json_msg['party_id'] !== jiff.id) {
+        for (var i = 0; i < json_msg['share'].length; i++) {
+          json_msg['share'][i] = jiff.hooks.decryptSign(jiff, json_msg['share'][i], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
+        }
+        json_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'open', json_msg], 2);
+      }
+
+      var sender_id = json_msg['party_id'];
+      var op_id = json_msg['op_id'];
+      var share = json_msg['share'];
+      var Zp = json_msg['Zp'];
+
+      // call hook
+      share = jiff.execute_array_hooks('receiveOpen', [jiff, sender_id, share, Zp], 2);
+
+      // Resolve the deferred.
+      if (jiff.deferreds[op_id] == null) {
+        jiff.deferreds[op_id] = {};
+      }
+      if (jiff.deferreds[op_id][sender_id] == null) {
+        jiff.deferreds[op_id][sender_id] = new Deferred();
+      }
+
+      jiff.deferreds[op_id][sender_id].resolve({value: share, sender_id: sender_id, Zp: Zp});
+    }
+
+    function jiff_broadcast(jiff, share, parties, op_ids) {
+      for (var index = 0; index < parties.length; index++) {
+        var i = parties[index]; // Party id
+        if (i === jiff.id) {
+          receive_open(jiff, {party_id: i, share: share.value, op_id: op_ids[i], Zp: share.Zp});
+          continue;
+        }
+
+        // encrypt, sign and send
+        var msg = {party_id: i, share: share.value, op_id: op_ids[i], Zp: share.Zp};
+        msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'open', msg], 2);
+
+        for (var j = 0; j < msg['share'].length; j++) {
+          msg['share'][j] = jiff.hooks.encryptSign(jiff, msg['share'][j].toString(), jiff.keymap[msg['party_id']], jiff.secret_key);
+        }
+        jiff.socket.safe_emit('open', JSON.stringify(msg));
+      }
+    }
+
+    function jiff_lagrange(jiff, shares) {
+      var lagrange_coeff = []; // will contain shares.length many elements.
+
+      // Compute the Langrange coefficients at 0.
+      for (var i = 0; i < shares.length; i++) {
+        var pi = jiff.helpers.get_party_number(shares[i].sender_id);
+        lagrange_coeff[pi] = 1;
+
+        for (var j = 0; j < shares.length; j++) {
+          var pj = jiff.helpers.get_party_number(shares[j].sender_id);
+          if (pj !== pi) {
+            var inv = jiff.helpers.extended_gcd(pi - pj, shares[i].Zp)[0];
+            lagrange_coeff[pi] = jiff.helpers.mod(lagrange_coeff[pi] * (0 - pj), shares[i].Zp) * inv;
+            lagrange_coeff[pi] = jiff.helpers.mod(lagrange_coeff[pi], shares[i].Zp);
+          }
+        }
+      }
+
+      // Reconstruct the secret via Lagrange interpolation
+      var recons_secret = 0;
+      for (var p = 0; p < shares.length; p++) {
+        var party = jiff.helpers.get_party_number(shares[p].sender_id);
+        var tmp = jiff.helpers.mod((shares[p].value * lagrange_coeff[party]), shares[p].Zp);
+        recons_secret = jiff.helpers.mod((recons_secret + tmp), shares[p].Zp);
+      }
+
+      return recons_secret;
+    }
+
+    var old_share = jiff.share;
+    jiff.share = function (secret, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios) {
+      receivers_ratios = {};
+      for (var i = 1; i < jiff.party_count; i++) {
+        receivers_ratios[i] = 2;
+      }
+      if (receivers_ratios == null){
+        var result = old_share(secret, threshold, receivers_list, senders_list, Zp, share_id);
+        return result;
+      }
+      else{
+        var i, j, p_id;
+
+        // change afterOperation hook to handle array of shares
+        jiff.hooks.afterOperation = (function (jiff, label, msg) {
+          if (label === 'share' || label === 'open') {
+            for (var i = 0; i < msg['share'].length; i++) {
+              msg['share'][i] = parseInt(msg['share'][i], 10);
+            }
+          }
+          return msg;
+        });
+
+        // defaults
+        if (Zp == null) {
+          Zp = jiff.Zp;
+        }
+        if (receivers_list == null) {
+          receivers_list = [];
+          for (i = 1; i <= jiff.party_count; i++) {
+            receivers_list.push(i);
+          }
+        }
+        if (senders_list == null) {
+          senders_list = [];
+          for (i = 1; i <= jiff.party_count; i++) {
+            senders_list.push(i);
+          }
+        }
+        if (threshold == null) {
+          threshold = receivers_list.length;
+        }
+        if (threshold < 0) {
+          threshold = 2;
+        }
+        if (threshold > receivers_list.length) {
+          threshold = receivers_list.length;
+        }
+
+        // if party is uninvolved in the share, do nothing
+        if (receivers_list.indexOf(jiff.id) === -1 && senders_list.indexOf(jiff.id) === -1) {
+          return {};
+        }
+
+        // compute operation id
+        receivers_list.sort(); // sort to get the same order
+        senders_list.sort();
+        if (share_id == null) {
+          share_id = jiff.counters.gen_share_id(receivers_list, senders_list);
+        }
+
+        // stage sending of shares
+        if (senders_list.indexOf(jiff.id) > -1) {
+          // Call hook
+          secret = jiff.execute_array_hooks('beforeShare', [jiff, secret, threshold, receivers_list, senders_list, Zp], 1);
+
+          // compute shares
+          var shares = jiff_compute_shares(jiff, secret, receivers_list, threshold, Zp, receivers_ratios);
+
+          // Call hook
+          shares = jiff.execute_array_hooks('afterComputeShare', [jiff, shares, threshold, receivers_list, senders_list, Zp], 1);
+
+          // send shares
+          for (i = 0; i < receivers_list.length; i++) {
+            p_id = receivers_list[i];
+            if (p_id === jiff.id) {
+              continue;
+            }
+
+            // send encrypted and signed shares_id[p_id] to party p_id
+            var p_ratio = (p_id in receivers_ratios) ? receivers_ratios[p_id] : 1;
+            var msg = { party_id: p_id, share: shares[p_id], op_id: share_id };
+            msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'share', msg], 2);
+            for (j = 0; j < p_ratio; j++) {
+              msg['share'][j] = jiff.hooks.encryptSign(jiff, msg['share'][j].toString(10), jiff.keymap[msg['party_id']], jiff.secret_key);
+            }
+            jiff.socket.safe_emit('share', JSON.stringify(msg));
+          }
+        }
+
+        // stage receiving of shares
+        var result = {};
+        if (receivers_list.indexOf(jiff.id) > -1) {
+          // setup a map of deferred for every received share
+          if (jiff.deferreds[share_id] == null) {
+            jiff.deferreds[share_id] = {};
+          }
+
+          for (i = 0; i < senders_list.length; i++) {
+            p_id = senders_list[i];
+            if (p_id === jiff.id) {
+              var my_share = jiff.execute_array_hooks('receiveShare', [jiff, p_id, shares[p_id]], 2);
+              result[p_id] = jiff.secret_share(jiff, true, null, my_share, receivers_list, threshold, Zp);
+              continue; // Keep party's own share
+            }
+
+            // check if a deferred is set up (maybe the message was previously received)
+            if (jiff.deferreds[share_id][p_id] == null) {
+              // not ready, setup a deferred
+              jiff.deferreds[share_id][p_id] = new Deferred();
+            }
+
+            var promise = jiff.deferreds[share_id][p_id].promise;
+
+            // destroy deferred when done
+            (function (promise, p_id) { // p_id is modified in a for loop, must do this to avoid scoping issues.
+              promise.then(function () {
+                jiff.deferreds[share_id][p_id] = null;
+              });
+            })(promise, p_id);
+
+            // receive share_i[id] from party p_id
+            result[p_id] = jiff.secret_share(jiff, false, promise, undefined, receivers_list, threshold, Zp, share_id + ':' + p_id);
+          }
+        }
+        return result;
+      }
+    }
+
+    function jiff_compute_shares(jiff, secret, parties_list, threshold, Zp, parties_ratios) {
+      var shares = {}; // Keeps the shares
+      var i;
+
+      // Each player's random polynomial f must have
+      // degree threshold - 1, so that threshold many points are needed
+      // to interpolate/reconstruct.
+      var t = threshold - 1;
+      var polynomial = Array(t + 1); // stores the coefficients
+
+      // Each players's random polynomial f must be constructed
+      // such that f(0) = secret
+      polynomial[0] = secret;
+
+      // Compute the random polynomial f's coefficients
+      for (i = 1; i <= t; i++) {
+        polynomial[i] = jiff.helpers.random(Zp);
+      }
+
+      // Compute each players share such that share[i] = f(i)
+      for (i = 0; i < parties_list.length; i++) {
+        var p_id = parties_list[i];
+        var p_ratio = p_id in parties_ratios ? parties_ratios[p_id] : 1;
+        shares[p_id] = [];
+        for (var share_num = 0; share_num < p_ratio; share_num++) {
+          shares[p_id][share_num] = polynomial[0];
+          var power = jiff.helpers.get_party_number(p_id, share_num);
+
+          for (var j = 1; j < polynomial.length; j++) {
+            var tmp = jiff.helpers.mod((polynomial[j] * power), Zp);
+            shares[p_id][share_num] = jiff.helpers.mod((shares[p_id][share_num] + tmp), Zp);
+            power = jiff.helpers.mod(power * jiff.helpers.get_party_number(p_id, share_num), Zp);
+          }
+        }
+      }
+      return shares;
+    }
+
+    function receive_share(jiff, json_msg) {
+      // Decrypt share
+      var num_shares = json_msg['share'].length;
+      for (var i = 0; i < num_shares; i++) {
+        json_msg['share'][i] = jiff.hooks.decryptSign(jiff, json_msg['share'][i], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
+      }
+      json_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'share', json_msg], 2);
+
+      var sender_id = json_msg['party_id'];
+      var op_id = json_msg['op_id'];
+      var share = json_msg['share'];
+
+      // Call hook
+      share = jiff.execute_array_hooks('receiveShare', [jiff, sender_id, share], 2);
+
+      // check if a deferred is set up (maybe the share was received early)
+      if (jiff.deferreds[op_id] == null) {
+        jiff.deferreds[op_id] = {};
+      }
+      if (jiff.deferreds[op_id][sender_id] == null) {
+        // Share is received before deferred was setup, store it.
+        jiff.deferreds[op_id][sender_id] = new Deferred();
+      }
+
+      // Deferred is already setup, resolve it.
+      jiff.deferreds[op_id][sender_id].resolve(share);
+    }
+
+    function Deferred() {
+      // Polyfill for jQuery Deferred
+      // From https://developer.mozilla.org/en-US/docs/Mozilla/JavaScript_code_modules/Promise.jsm/Deferred
+      this.resolve = null;
+
+      /* A method to reject the associated Promise with the value passed.
+       * If the promise is already settled it does nothing.
+       *
+       * @param {anything} reason: The reason for the rejection of the Promise.
+       * Generally its an Error object. If however a Promise is passed, then the Promise
+       * itself will be the reason for rejection no matter the state of the Promise.
+       */
+      this.reject = null;
+
+      /* A newly created Promise object.
+       * Initially in pending state.
+       */
+      this.promise = new Promise(function (resolve, reject) {
+        this.resolve = resolve;
+        this.reject = reject;
+      }.bind(this));
+      Object.freeze(this);
+    }
+
+    /* HOOKS */
+    jiff.hooks.createSecretShare.push(createMultipleSharesSecretShare);
+
+    return jiff;
+  }
+
+  // Expose API
+  exports.make_jiff = make_jiff;
+
+}((typeof exports === 'undefined' ? this.jiff_multipleshares = {} : exports), typeof exports !== 'undefined'));
\ No newline at end of file
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index a63ee352c..18768c830 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -289,7 +289,6 @@
         result[p_id] = jiff.secret_share(jiff, false, promise, undefined, receivers_list, threshold, Zp, share_id + ':' + p_id);
       }
     }
-
     return result;
   }
 
@@ -473,7 +472,7 @@
           promise.then(function (received_share) {
             jiff.deferreds[op_ids[jiff.id]][p_id] = null;
             shares.push(received_share);
-
+            console.log(shares);
             // Too few shares, nothing to do.
             if (shares.length < share.threshold) {
               return;

From c85c0b165cf795aa8701c5229d8d357b05799f25 Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Mon, 24 Jun 2019 15:52:24 -0400
Subject: [PATCH 02/24] multipleshareExt

---
 lib/ext/jiff-client-multipleshares.js | 29 ++++++++++++++-------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/lib/ext/jiff-client-multipleshares.js b/lib/ext/jiff-client-multipleshares.js
index 905e9f7ae..dde4bd574 100644
--- a/lib/ext/jiff-client-multipleshares.js
+++ b/lib/ext/jiff-client-multipleshares.js
@@ -240,7 +240,7 @@
     var old_share = jiff.share;
     jiff.share = function (secret, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios) {
       receivers_ratios = {};
-      for (var i = 1; i < jiff.party_count; i++) {
+      for (var i = 1; i <= jiff.party_count; i++) {
         receivers_ratios[i] = 2;
       }
       if (receivers_ratios == null){
@@ -248,17 +248,7 @@
         return result;
       }
       else{
-        var i, j, p_id;
-
-        // change afterOperation hook to handle array of shares
-        jiff.hooks.afterOperation = (function (jiff, label, msg) {
-          if (label === 'share' || label === 'open') {
-            for (var i = 0; i < msg['share'].length; i++) {
-              msg['share'][i] = parseInt(msg['share'][i], 10);
-            }
-          }
-          return msg;
-        });
+        var i, j, p_id, p_ratio;
 
         // defaults
         if (Zp == null) {
@@ -317,9 +307,9 @@
             }
 
             // send encrypted and signed shares_id[p_id] to party p_id
-            var p_ratio = (p_id in receivers_ratios) ? receivers_ratios[p_id] : 1;
-            var msg = { party_id: p_id, share: shares[p_id], op_id: share_id };
+            var msg = { party_id: p_id, share: shares[p_id], op_id: share_id, p_ratio: p_ratio};
             msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'share', msg], 2);
+            p_ratio = (p_id in receivers_ratios) ? receivers_ratios[p_id] : 1;
             for (j = 0; j < p_ratio; j++) {
               msg['share'][j] = jiff.hooks.encryptSign(jiff, msg['share'][j].toString(10), jiff.keymap[msg['party_id']], jiff.secret_key);
             }
@@ -337,6 +327,7 @@
 
           for (i = 0; i < senders_list.length; i++) {
             p_id = senders_list[i];
+            p_ratio = (p_id in receivers_ratios) ? receivers_ratios[p_ratio] : 1;
             if (p_id === jiff.id) {
               var my_share = jiff.execute_array_hooks('receiveShare', [jiff, p_id, shares[p_id]], 2);
               result[p_id] = jiff.secret_share(jiff, true, null, my_share, receivers_list, threshold, Zp);
@@ -410,6 +401,16 @@
       for (var i = 0; i < num_shares; i++) {
         json_msg['share'][i] = jiff.hooks.decryptSign(jiff, json_msg['share'][i], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
       }
+
+      // change afterOperation hook to handle array of shares
+      jiff.hooks.afterOperation = (function (jiff, label, msg) {
+        if (label === 'share' || label === 'open') {
+          for (var i = 0; i < msg['share'].length; i++) {
+            msg['share'][i] = parseInt(msg['share'][i], 10);
+          }
+        }
+        return msg;
+      });
       json_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'share', json_msg], 2);
 
       var sender_id = json_msg['party_id'];

From f05c8e20d815a1f01cc90df9ef10721817889871 Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Fri, 28 Jun 2019 14:38:59 -0400
Subject: [PATCH 03/24] arithmetic operations

---
 demos/multipleshares/client.html         |    2 +-
 demos/multipleshares/mpc.js              |   16 +-
 lib/ext/jiff-client-asynchronousshare.js | 1575 ++++++++++++++++++++++
 lib/ext/jiff-client-multipleshares.js    |  469 -------
 lib/jiff-client.js                       |   24 +-
 5 files changed, 1602 insertions(+), 484 deletions(-)
 create mode 100644 lib/ext/jiff-client-asynchronousshare.js
 delete mode 100644 lib/ext/jiff-client-multipleshares.js

diff --git a/demos/multipleshares/client.html b/demos/multipleshares/client.html
index d38051083..f1c0874ce 100644
--- a/demos/multipleshares/client.html
+++ b/demos/multipleshares/client.html
@@ -12,7 +12,7 @@
     <script src="/socket.io/socket.io.js"></script>
     <script src="/lib/sodium.js"></script>
     <script src="/lib/jiff-client.js"></script>
-    <script src="/lib/ext/jiff-client-multipleshares.js"></script>
+    <script src="/lib/ext/jiff-client-asynchronousshare.js"></script>
 
     <!-- Contains UI Handlers and Input Checks -->
     <script type="text/javascript" src="./client.js"></script>
diff --git a/demos/multipleshares/mpc.js b/demos/multipleshares/mpc.js
index c6c7166b6..33ad9b949 100644
--- a/demos/multipleshares/mpc.js
+++ b/demos/multipleshares/mpc.js
@@ -10,14 +10,13 @@
     if (node) {
       // eslint-disable-next-line no-undef
       jiff = require('../../lib/jiff-client');
-      jiff_fixedpoint = require('../../lib/ext/jiff-client-fixedpoint');
-      jiff_multipleshares = require('../../lib/ext/jiff-client-multipleshares');
+      jiff_asynchronousshare = require('../../lib/ext/jiff-client-asynchronousshare');
     }
 
     opt.autoConnect = false;
     // eslint-disable-next-line no-undef
     saved_instance = jiff.make_jiff(hostname, computation_id, opt);
-    saved_instance.apply_extension(jiff_multipleshares, opt);
+    saved_instance.apply_extension(jiff_asynchronousshare, opt);
     saved_instance.connect();
     return saved_instance;
   };
@@ -33,12 +32,13 @@
     // The MPC implementation should go *HERE*
     var shares = jiff_instance.share(input);
     var sum = shares[1];
-    console.log(shares);
-    //for (var i = 2; i <= jiff_instance.party_count; i++) {
-    //  sum = sum.sadd(shares[i]);
-    //}
 
+    for (var i = 2; i <= jiff_instance.party_count; i++) {
+      sum = sum.sdiv(shares[i]);
+    }
+    console.log(sum);
     // Return a promise to the final output(s)
-    //return jiff_instance.open(sum);
+    var result = jiff_instance.open(sum);
+    return result;
   };
 }((typeof exports === 'undefined' ? this.mpc = {} : exports), typeof exports !== 'undefined'));
diff --git a/lib/ext/jiff-client-asynchronousshare.js b/lib/ext/jiff-client-asynchronousshare.js
new file mode 100644
index 000000000..b61088c5f
--- /dev/null
+++ b/lib/ext/jiff-client-asynchronousshare.js
@@ -0,0 +1,1575 @@
+/**
+ * @namespace jiff_fixedpoint
+ * @version 1.0
+ */
+(function (exports, node) {
+  /**
+   * The name of this extension: 'multipleshares'
+   * @type {string}
+   * @memberOf jiff_multipleshares
+   */
+  exports.name = 'asynchronousshare';
+
+  function Deferred() {
+    // Polyfill for jQuery Deferred
+    // From https://developer.mozilla.org/en-US/docs/Mozilla/JavaScript_code_modules/Promise.jsm/Deferred
+    this.resolve = null;
+
+    /* A method to reject the associated Promise with the value passed.
+     * If the promise is already settled it does nothing.
+     *
+     * @param {anything} reason: The reason for the rejection of the Promise.
+     * Generally its an Error object. If however a Promise is passed, then the Promise
+     * itself will be the reason for rejection no matter the state of the Promise.
+     */
+    this.reject = null;
+
+    /* A newly created Promise object.
+     * Initially in pending state.
+     */
+    this.promise = new Promise(function (resolve, reject) {
+      this.resolve = resolve;
+      this.reject = reject;
+    }.bind(this));
+    Object.freeze(this);
+  }
+
+  function createMultipleSharesSecretShare(jiff, share, share_helpers) {
+    // Keep a copy of the previous implementation of changed primitives
+    share.legacy = {};
+    var internals = ['cadd', 'sadd', 'csub', 'ssub',
+      'cmult', 'smult', 'smult_bgw',
+      'cdivfac', 'cdiv', 'sdiv', 'smod',
+      'cxor_bit', 'sxor_bit', 'cor_bit', 'sor_bit', 'not',
+      'slt', 'slteq', 'sgt', 'sgteq', 'seq', 'sneq',
+      'clt', 'clteq', 'cgt', 'cgteq', 'ceq', 'cneq',
+      'lt_halfprime', 'if_else' ];
+    for (var i = 0; i < internals.length; i++) {
+      var key = internals[i];
+      share.legacy[key] = share[key];
+    }
+
+    function max(x, y) {
+      return x > y ? x : y;
+    }
+
+    share.cadd = function (o) {
+      var ready_add = function () {
+        if (!(share.isConstant(o))) {
+          throw new Error('parameter should be a number (+)');
+        }
+        var result = [];
+        for (var i = 0; i < share.value.length; i++) {
+          result.push(jiff.helpers.mod(share_helpers['+'](share.value[i], o), share.Zp));
+        }
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cadd(o);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_add(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cadd(o).value;
+        } else {
+          return ready_add();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+    
+    share.sadd = function (o) {
+      var result, addshare;
+
+      var ready_add = function () {
+        if (!(o.jiff === share.jiff)) {
+          throw new Error('shares do not belong to the same instance (+)');
+        }
+        if (!share.jiff.helpers.Zp_equals(share, o)) {
+          throw new Error('shares must belong to the same field (+)');
+        }
+        if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
+          throw new Error('shares must be held by the same parties (+)');
+        }
+
+        result = [];
+        for (var i = 0; i < share.value.length; i++) {
+          result.push(share.jiff.helpers.mod(share_helpers['+'](share.value[i], o.value[i]), share.Zp));
+        }
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.sadd(o);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_add(), share.holders, max(share.threshold, o.threshold), share.Zp);
+        }
+      }
+
+      var promise = share.pick_promise(o).then( function () {
+        if (typeof (share.value) === 'number') {
+          addshare = share.legacy.sadd(o);
+          if (addshare.ready) {
+            return addshare.value;
+          } else {
+            result = addshare.promise.then(function () {
+              return addshare.value;
+            });
+            return result;
+          }
+        } else {
+          return ready_add();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+    };
+
+    share.csub = function (o) {
+      var ready_sub = function () {
+        var result = [];
+        for (var i = 0; i < share.value.length; i++) {
+          result.push(jiff.helpers.mod(share_helpers['-'](share.value[i], o), share.Zp));
+        }
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.csub(o);
+        } else {
+          share.jiff.secret_share(share.jiff, true, null, ready_sub(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.csub(o).value;
+        } else {
+          return ready_sub();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    share.ssub = function (o) {
+      var result, subshare;
+
+      var ready_sub = function () {
+        if (!(o.jiff === share.jiff)) {
+          throw new Error('shares do not belong to the same instance (+)');
+        }
+        if (!share.jiff.helpers.Zp_equals(share, o)) {
+          throw new Error('shares must belong to the same field (+)');
+        }
+        if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
+          throw new Error('shares must be held by the same parties (+)');
+        }
+
+        var result = [];
+        for (var i = 0; i < share.value.length; i++) {
+          result.push(share.jiff.helpers.mod(share_helpers['-'](share.value[i], o.value[i]), share.Zp));
+        }
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.ssub(o);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_sub(), share.holders, max(share.threshold, o.threshold), share.Zp);
+        }
+      }
+
+      // promise to execute ready_add when both are ready
+      var promise = share.pick_promise(o).then( function () {
+        if (typeof (share.value) === 'number') {
+          subshare = share.legacy.ssub(o);
+          if (subshare.ready) {
+            return subshare.value;
+          } else {
+            result = subshare.promise.then(function () {
+              return subshare.value;
+            });
+            return result;
+          }
+        } else {
+          return ready_sub();
+        }
+      });
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+    };
+
+    share.cmult = function (o) {
+      var ready_mult = function () {
+        if (!(share.isConstant(o))) {
+          throw new Error('parameter should be a number (*)');
+        }
+
+        var result = [];
+        for (var i = 0; i < share.value.length; i++) {
+          result.push(jiff.helpers.mod(share_helpers['*'](share.value[i], o), share.Zp));
+        }
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cmult(o);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_mult(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cmult(o).value;
+        } else {
+          return ready_mult();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    share.smult = function (o, op_id) {
+      var result, multshare;
+
+      var ready_mult = function () {
+        result = [];
+        var share_val = share.value;
+        var o_val = o.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          o.value = o_val[i];
+          multshare = share.legacy.smult(o, op_id);
+          if (multshare.ready) {
+            return multshare.value;
+          } else {
+            multshare.promise.then(function () {
+              result.push(multshare.value);
+            });
+          }
+        }
+        share.value = share_val;
+        o.value = o_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.smult(o, op_id);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_mult(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      // promise to execute ready_add when both are ready
+      var promise = share.pick_promise(o).then( function () {
+        if (typeof (share.value) === 'number') {
+          multshare = share.legacy.smult(o);
+          if (multshare.ready) {
+            return multshare.value;
+          } else {
+            result = multshare.promise.then(function () {
+            return multshare.value;
+            });
+            return result;
+          }
+        } else {
+          return ready_mult();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+    };
+
+
+    share.smult_bgw = function(o, op_id) {
+      var result, multshare;
+
+      var ready_mult_bgw = function () {
+        result = [];
+        var share_val = share.value;
+        var o_val = o.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          o.value = o_val[i];
+          multshare = share.legacy.smult_bgw(o, op_id);
+          if (multshare.ready) {
+            return multshare.value;
+          } else {
+            multshare.promise.then(function () {
+              result.push(multshare.value);
+            });
+          }
+        }
+        share.value = share_val;
+        o.value = o_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.smult_bgw(o, op_id);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_mult_bgw(), share.holders, max(share.threshold, o.threshold), share.Zp);
+        }
+      }
+
+      // promise to execute ready_add when both are ready
+      var promise = share.pick_promise(o).then( function () {
+        if (typeof (share.value) === 'number') {
+          multshare = share.legacy.smult_bgw(o);
+          if (multshare.ready) {
+            return multshare.value;
+          } else {
+            result = multshare.promise.then(function () {
+              return multshare.value;
+            });
+            return result;
+          }
+        } else {
+          return ready_mult_bgw();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+    };
+
+    share.cdiv = function (o, op_id) {
+      var ready_div = function () {
+        var result = [];
+        var share_val = share.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          result.push(share.legacy.cdiv(o, op_id).value);
+        }
+        share.value = share_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cdiv(o, op_id).value;
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_div(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cdiv(o, op_id).value;
+        } else {
+          return ready_div();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    share.cdivfac = function (o) {
+      var ready_div = function () {
+        var result = [];
+        var share_val = share.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          result.push(share.legacy.cdivfac(o).value);
+        }
+        share.value = share_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cdivfac(o).value;
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_div(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cdivfac(o).value;
+        } else {
+          return ready_div();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    share.sdiv = function (o, l, op_id) {
+      console.log(share, o);
+      var result, divshare;
+
+      var ready_div = function () {
+        result = [];
+        var share_val = share.value;
+        var o_val = o.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          o.value = o_val[i];
+          divshare = share.legacy.sdiv(o, l, op_id);
+          if (divshare.ready) {
+            return divshare.value;
+          } else {
+            divshare.promise.then(function () {
+              result.push(divshare.value);
+            });
+          }
+        }
+        share.value = share_val;
+        o.value = o_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.sdiv(o, l, op_id);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_div(), share.holders, max(share.threshold, o.threshold), share.Zp);
+        }
+      }
+
+      // promise to execute ready_add when both are ready
+      var promise = share.pick_promise(o).then( function () {
+        if (typeof (share.value) === 'number') {
+          console.log(o);
+          divshare = share.legacy.sdiv(o, l, op_id);
+          console.log(divshare);
+          if (divshare.ready) {
+            return divshare.value;
+          }
+          result = divshare.promise.then(function () {
+            console.log(divshare);
+            return divshare.value;
+          });
+          return result;
+        } else {
+          return ready_div();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+    };
+
+    share.smod = function (o, l, op_id) {
+      var mult_deferred = new Deferred();
+      var finalpromise = mult_deferred.promise;
+
+      var ready_mod = function () {
+        var result = [];
+        var share_val = share.value;
+        var o_val = o.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          o.value = o_val[i];
+          result.push(share.legacy.smod(o, l, op_id).value);
+        }
+        share.value = share_val;
+        o.value = o_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.smod(o, l, op_id);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_mod(), share.holders, max(share.threshold, o.threshold), share.Zp);
+        }
+      }
+
+      // promise to execute ready_add when both are ready
+      share.pick_promise(o).then( function () {
+        if (typeof (share.value) === 'number') {
+          var result = share.legacy.smod(o, l, op_id);
+          result.promise.then(function () {
+            mult_deferred.resolve(result.value);
+          });
+        } else {
+          mult_deferred.resolve(ready_mod());
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+    };
+
+    share.cxor_bit = function (o) {
+      var ready_xor_bit = function () {
+        var result = [];
+        var share_val = share.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          result.push(share.legacy.cxor_bit(o).value);
+        }
+        share.value = share_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cxor_bit(o).value;
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_xor_bit(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cxor_bit(o).value;
+        } else {
+          return ready_xor_bit();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    share.sxor_bit = function (o, op_id) {
+      var mult_deferred = new Deferred();
+      var finalpromise = mult_deferred.promise;
+
+      var ready_xor_bit = function () {
+        var result = [];
+        var share_val = share.value;
+        var o_val = o.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          o.value = o_val[i];
+          result.push(share.legacy.sxor_bit(o, op_id).value);
+        }
+        share.value = share_val;
+        o.value = o_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.sxor_bit(o, op_id);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_xor_bit(), share.holders, max(share.threshold, o.threshold), share.Zp);
+        }
+      }
+
+      // promise to execute ready_add when both are ready
+      share.pick_promise(o).then( function () {
+        if (typeof (share.value) === 'number') {
+          var result = share.legacy.sxor_bit(o, op_id);
+          result.promise.then(function () {
+            mult_deferred.resolve(result.value);
+          });
+        } else {
+          mult_deferred.resolve(ready_xor_bit());
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+    };
+
+    share.cor_bit = function (o) {
+      var ready_or_bit = function () {
+        var result = [];
+        var share_val = share.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          result.push(share.legacy.cor_bit(o).value);
+        }
+        share.value = share_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cor_bit(o).value;
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_or_bit(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cor_bit(o).value;
+        } else {
+          return ready_or_bit();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    share.sor_bit = function (o, op_id) {
+      var mult_deferred = new Deferred();
+      var finalpromise = mult_deferred.promise;
+
+      var ready_or_bit = function () {
+        var result = [];
+        var share_val = share.value;
+        var o_val = o.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          o.value = o_val[i];
+          result.push(share.legacy.sor_bit(o, op_id).value);
+        }
+        share.value = share_val;
+        o.value = o_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.sor_bit(o, op_id);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_or_bit(), share.holders, max(share.threshold, o.threshold), share.Zp);
+        }
+      }
+
+      // promise to execute ready_add when both are ready
+      share.pick_promise(o).then( function () {
+        if (typeof (share.value) === 'number') {
+          var result = share.legacy.sor_bit(o, op_id);
+          result.promise.then(function () {
+            mult_deferred.resolve(result.value);
+          });
+        } else {
+          mult_deferred.resolve(ready_or_bit());
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+    };
+
+    share.clt = function (o, op_id) {
+      var ready_lt = function () {
+        var result = [];
+        var share_val = share.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          result.push(share.legacy.clt(o, op_id).value);
+        }
+        share.value = share_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.clt(o, op_id).value;
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_lt(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.clt(o, op_id).value;
+        } else {
+          return ready_lt();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    share.clteq = function (o, op_id) {
+      var ready_lteq = function () {
+        var result = [];
+        var share_val = share.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          result.push(share.legacy.clteq(o, op_id).value);
+        }
+        share.value = share_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.clteq(o, op_id).value;
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_lteq(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.clteq(o, op_id).value;
+        } else {
+          return ready_lteq();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    share.cgt = function (o, op_id) {
+      var ready_gt = function () {
+        var result = [];
+        var share_val = share.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          result.push(share.legacy.cgt(o, op_id).value);
+        }
+        share.value = share_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cgt(o, op_id).value;
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_gt(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cgt(o, op_id).value;
+        } else {
+          return ready_gt();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    share.cgteq = function (o, op_id) {
+      var ready_gteq = function () {
+        var result = [];
+        var share_val = share.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          result.push(share.legacy.cgteq(o, op_id).value);
+        }
+        share.value = share_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cgteq(o, op_id).value;
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_gteq(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cgteq(o, op_id).value;
+        } else {
+          return ready_gteq();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    share.ceq = function (o, op_id) {
+      var ready_eq = function () {
+        var result = [];
+        var share_val = share.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          result.push(share.legacy.ceq(o, op_id).value);
+        }
+        share.value = share_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.ceq(o, op_id).value;
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_eq(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.ceq(o, op_id).value;
+        } else {
+          return ready_eq();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    share.cneq = function (o, op_id) {
+      var ready_neq = function () {
+        var result = [];
+        var share_val = share.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          result.push(share.legacy.cneq(o, op_id).value);
+        }
+        share.value = share_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cneq(o, op_id).value;
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_neq(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.cneq(o, op_id).value;
+        } else {
+          return ready_neq();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    share.slt = function (o, op_id) {
+      var mult_deferred = new Deferred();
+      var finalpromise = mult_deferred.promise;
+
+      var ready_lt = function () {
+        var result = [];
+        var share_val = share.value;
+        var o_val = o.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          o.value = o_val[i];
+          result.push(share.legacy.slt(o, op_id).value);
+        }
+        share.value = share_val;
+        o.value = o_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.slt(o, op_id);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_lt(), share.holders, max(share.threshold, o.threshold), share.Zp);
+        }
+      }
+
+      // promise to execute ready_add when both are ready
+      share.pick_promise(o).then( function () {
+        if (typeof (share.value) === 'number') {
+          var result = share.legacy.slt(o, op_id);
+          result.promise.then(function () {
+            mult_deferred.resolve(result.value);
+          });
+        } else {
+          mult_deferred.resolve(ready_lt());
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+    };
+
+    share.slteq = function (o, op_id) {
+      var mult_deferred = new Deferred();
+      var finalpromise = mult_deferred.promise;
+
+      var ready_lteq = function () {
+        var result = [];
+        var share_val = share.value;
+        var o_val = o.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          o.value = o_val[i];
+          result.push(share.legacy.slteq(o, op_id).value);
+        }
+        share.value = share_val;
+        o.value = o_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.slteq(o, op_id);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_lteq(), share.holders, max(share.threshold, o.threshold), share.Zp);
+        }
+      }
+
+      // promise to execute ready_add when both are ready
+      share.pick_promise(o).then( function () {
+        if (typeof (share.value) === 'number') {
+          var result = share.legacy.slteq(o, op_id);
+          result.promise.then(function () {
+            mult_deferred.resolve(result.value);
+          });
+        } else {
+          mult_deferred.resolve(ready_lteq());
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+    };
+
+    share.sgt = function (o, op_id) {
+      var mult_deferred = new Deferred();
+      var finalpromise = mult_deferred.promise;
+
+      var ready_gt = function () {
+        var result = [];
+        var share_val = share.value;
+        var o_val = o.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          o.value = o_val[i];
+          result.push(share.legacy.sgt(o, op_id).value);
+        }
+        share.value = share_val;
+        o.value = o_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.sgt(o, op_id);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_gt(), share.holders, max(share.threshold, o.threshold), share.Zp);
+        }
+      }
+
+      // promise to execute ready_add when both are ready
+      share.pick_promise(o).then( function () {
+        if (typeof (share.value) === 'number') {
+          var result = share.legacy.sgt(o, op_id);
+          result.promise.then(function () {
+            mult_deferred.resolve(result.value);
+          });
+        } else {
+          mult_deferred.resolve(ready_gt());
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+    };
+
+    share.sgteq = function (o, op_id) {
+      var mult_deferred = new Deferred();
+      var finalpromise = mult_deferred.promise;
+
+      var ready_gteq = function () {
+        var result = [];
+        var share_val = share.value;
+        var o_val = o.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          o.value = o_val[i];
+          result.push(share.legacy.sgteq(o, op_id).value);
+        }
+        share.value = share_val;
+        o.value = o_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.sgteq(o, op_id);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_gteq(), share.holders, max(share.threshold, o.threshold), share.Zp);
+        }
+      }
+
+      // promise to execute ready_add when both are ready
+      share.pick_promise(o).then( function () {
+        if (typeof (share.value) === 'number') {
+          var result = share.legacy.sgteq(o, op_id);
+          result.promise.then(function () {
+            mult_deferred.resolve(result.value);
+          });
+        } else {
+          mult_deferred.resolve(ready_gteq());
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+    };
+
+    share.seq = function (o, op_id) {
+      var mult_deferred = new Deferred();
+      var finalpromise = mult_deferred.promise;
+
+      var ready_eq = function () {
+        var result = [];
+        var share_val = share.value;
+        var o_val = o.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          o.value = o_val[i];
+          result.push(share.legacy.seq(o, op_id).value);
+        }
+        share.value = share_val;
+        o.value = o_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.seq(o, op_id);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_eq(), share.holders, max(share.threshold, o.threshold), share.Zp);
+        }
+      }
+
+      // promise to execute ready_add when both are ready
+      share.pick_promise(o).then( function () {
+        if (typeof (share.value) === 'number') {
+          var result = share.legacy.seq(o, op_id);
+          result.promise.then(function () {
+            mult_deferred.resolve(result.value);
+          });
+        } else {
+          mult_deferred.resolve(ready_eq());
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+    };
+
+    share.sneq = function (o, op_id) {
+      var mult_deferred = new Deferred();
+      var finalpromise = mult_deferred.promise;
+
+      var ready_neq = function () {
+        var result = [];
+        var share_val = share.value;
+        var o_val = o.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          o.value = o_val[i];
+          result.push(share.legacy.sneq(o, op_id).value);
+        }
+        share.value = share_val;
+        o.value = o_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.sneq(o, op_id);
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_neq(), share.holders, max(share.threshold, o.threshold), share.Zp);
+        }
+      }
+
+      // promise to execute ready_add when both are ready
+      share.pick_promise(o).then( function () {
+        if (typeof (share.value) === 'number') {
+          var result = share.legacy.sneq(o, op_id);
+          result.promise.then(function () {
+            mult_deferred.resolve(result.value);
+          });
+        } else {
+          mult_deferred.resolve(ready_neq());
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+    };
+
+    share.lt_halfprime = function (op_id) {
+      var ready_lt_halfprime = function () {
+        var result = [];
+        var share_val = share.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          result.push(share.legacy.lt_halfprime(op_id).value);
+        }
+        share.value = share_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.lt_halfprime(op_id).value;
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_lt_halfprime(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.lt_halfprime(op_id).value;
+        } else {
+          return ready_lt_halfprime();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    share.not = function () {
+      var ready_not = function () {
+        var result = [];
+        var share_val = share.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          result.push(share.legacy.not().value);
+        }
+        share.value = share_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.not().value;
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_not(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.not().value;
+        } else {
+          return ready_not();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    share.if_else = function (trueVal, falseVal, op_id) {
+      var ready_if_else = function () {
+        var result = [];
+        var share_val = share.value;
+        for (var i = 0; i < share.value.length; i++) {
+          share.value = share_val[i];
+          result.push(share.legacy.if_else(trueVal, falseVal, op_id).value);
+        }
+        share.value = share_val;
+        return result;
+      };
+
+      if (share.ready && o.ready) {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.if_else(trueVal, falseVal, op_id).value;
+        } else {
+          return share.jiff.secret_share(share.jiff, true, null, ready_if_else(), share.holders, share.threshold, share.Zp);
+        }
+      }
+
+      var promise = share.promise.then( function () {
+        if (typeof (share.value) === 'number') {
+          return share.legacy.if_else(trueVal, falseVal, op_id).value;
+        } else {
+          return ready_if_else();
+        }
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+    };
+
+    return share;
+  }
+
+  function afterOperationMultipleShares (jiff, label, msg) {
+    if (label === 'share' || label === 'open') {
+      if (msg['share'].length >= 1) {
+        for (var i = 0; i < msg['share'].length; i++) {
+          msg['share'][i] = parseInt(msg['share'][i], 10);
+        }
+      } else {
+        msg['share'] = parseInt(msg['share'], 10);
+      }
+    }
+    return msg;
+  };
+
+  function make_jiff(base_instance, options) {
+    var jiff = base_instance;
+
+    // Parse options
+    if (options == null) {
+      options = {};
+    }
+
+    old_open = jiff.open;
+    jiff.open = function(share, parties, op_ids) {
+      var openresult;
+      var open_deferred = new Deferred();
+      var open_promise = open_deferred.promise;
+
+      var jiff_open = function() {
+        var i;
+
+        if (!(share.jiff === jiff)) {
+          throw 'share does not belong to given instance';
+        }
+
+        // Default values
+        if (parties == null || parties === []) {
+          parties = [];
+          for (i = 1; i <= jiff.party_count; i++) {
+            parties.push(i);
+          }
+        } else {
+          parties.sort();
+        }
+
+        // If not a receiver nor holder, do nothing
+        if (share.holders.indexOf(jiff.id) === -1 && parties.indexOf(jiff.id) === -1) {
+          return null;
+        }
+
+        // Compute operation ids (one for each party that will receive a result
+        if (op_ids == null) {
+          op_ids = {};
+        }
+
+        if (typeof (op_ids) === 'string' || typeof (op_ids) === 'number') {
+          var tmp = {};
+          for (i = 0; i < parties.length; i++) {
+            tmp[parties[i]] = op_ids;
+          }
+          op_ids = tmp;
+        } else {
+          var holders_label = share.holders.join(',');
+          for (i = 0; i < parties.length; i++) {
+            if (op_ids[parties[i]] == null) {
+              op_ids[parties[i]] = jiff.counters.gen_open_id(parties[i], holders_label);
+            }
+          }
+        }
+
+        // Party is a holder
+        if (share.holders.indexOf(jiff.id) > -1) {
+          // Call hook
+          share = jiff.execute_array_hooks('beforeOpen', [jiff, share, parties], 1);
+
+          // refresh/reshare, so that the original share remains secret, instead
+          // a new share is sent/open without changing the actual value.
+          share = share.refresh('refresh:' + op_ids[parties[0]]);
+
+          // The given share has been computed, share it to all parties
+          if (share.ready) {
+            jiff_broadcast(jiff, share, parties, op_ids);
+          } else {
+            jiff.counters.pending_opens++;
+            // Share is not ready, setup sharing as a callback to its promise
+            share.promise.then(function () {
+              jiff.counters.pending_opens--;
+              jiff_broadcast(jiff, share, parties, op_ids);
+            }, share.error);
+          }
+        }
+
+        // Party is a receiver
+        if (parties.indexOf(jiff.id) > -1) {
+          console.log('receiving');
+          var shares = []; // this will store received shares
+          var numberofshares = 0;
+          var final_deferred = new Deferred(); // will be resolved when the final value is reconstructed
+          var final_promise = final_deferred.promise;
+          for (i = 0; i < share.holders.length; i++) {
+            var p_id = share.holders[i];
+
+            // Setup a deferred for receiving a share from party p_id
+            if (jiff.deferreds[op_ids[jiff.id]] == null) {
+              jiff.deferreds[op_ids[jiff.id]] = {};
+            }
+            if (jiff.deferreds[op_ids[jiff.id]][p_id] == null) {
+              jiff.deferreds[op_ids[jiff.id]][p_id] = new Deferred();
+            }
+
+            // Clean up deferred when fulfilled
+            var promise = jiff.deferreds[op_ids[jiff.id]][p_id].promise;
+
+            // destroy deferred when done
+            (function (promise, p_id) { // p_id is modified in a for loop, must do this to avoid scoping issues.
+              promise.then(function (received_share) {
+                jiff.deferreds[op_ids[jiff.id]][p_id] = null;
+                shares.push(received_share);
+                numberofshares += received_share['value'].length;
+
+                // Too few shares, nothing to do.
+                if (numberofshares < share.threshold) {
+                  return;
+                }
+
+                // Enough shares to reconstruct.
+                // If did not already reconstruct, do it.
+                if (final_deferred != null) {
+                  var recons_secret = jiff_lagrange(jiff, shares);
+                  recons_secret = jiff.execute_array_hooks('afterReconstructShare', [jiff, recons_secret], 1);
+                  final_deferred.resolve(recons_secret);
+                  final_deferred = null;
+                }
+
+                // If all shares were received, clean up.
+                if (shares.length === share.holders.length) {
+                  shares = null;
+                  jiff.deferreds[op_ids[jiff.id]] = null;
+                }
+              });
+            })(promise, p_id);
+          }
+          return final_promise;
+        }
+      };
+
+      if (share.ready) {
+        if (typeof (share.value) === 'number') {
+          openresult = old_open(share, parties, op_ids);
+          open_deferred.resolve(openresult);
+        } else {
+          openresult = jiff_open();
+          open_deferred.resolve(openresult)
+        }
+      } else {
+        share.promise.then(function () {
+          if (typeof (share.value) === 'number') {
+            openresult = old_open(share, parties, op_ids);
+            open_deferred.resolve(openresult)
+          } else {
+            openresult = jiff_open();
+            open_deferred.resolve(openresult)
+          }
+        }, share.error);
+      }
+
+    return open_promise;
+  };
+
+    function receive_open(jiff, json_msg) {
+      // Decrypt share
+      if (json_msg['party_id'] !== jiff.id) {
+        for (var i = 0; i < json_msg['share'].length; i++) {
+          json_msg['share'][i] = jiff.hooks.decryptSign(jiff, json_msg['share'][i], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
+        }
+        json_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'open', json_msg], 2);
+      }
+
+      var sender_id = json_msg['party_id'];
+      var op_id = json_msg['op_id'];
+      var share = json_msg['share'];
+      var Zp = json_msg['Zp'];
+
+      // call hook
+      share = jiff.execute_array_hooks('receiveOpen', [jiff, sender_id, share, Zp], 2);
+
+      // Resolve the deferred.
+      if (jiff.deferreds[op_id] == null) {
+        jiff.deferreds[op_id] = {};
+      }
+      if (jiff.deferreds[op_id][sender_id] == null) {
+        jiff.deferreds[op_id][sender_id] = new Deferred();
+      }
+
+      jiff.deferreds[op_id][sender_id].resolve({value: share, sender_id: sender_id, Zp: Zp});
+    }
+
+    function jiff_broadcast(jiff, share, parties, op_ids) {
+      for (var index = 0; index < parties.length; index++) {
+        var i = parties[index]; // Party id
+        if (i === jiff.id) {
+          receive_open(jiff, {party_id: i, share: share.value, op_id: op_ids[i], Zp: share.Zp});
+          continue;
+        }
+
+        // encrypt, sign and send
+        var msg = {party_id: i, share: share.value.slice(), op_id: op_ids[i], Zp: share.Zp};
+        msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'open', msg], 2);
+
+        for (var j = 0; j < msg['share'].length; j++) {
+          msg['share'][j] = jiff.hooks.encryptSign(jiff, msg['share'][j].toString(), jiff.keymap[msg['party_id']], jiff.secret_key);
+        }
+        jiff.socket.safe_emit('open', JSON.stringify(msg));
+      }
+    }
+
+
+    function jiff_lagrange(jiff, shares) {
+      var lagrange_coeff = []; // will contain shares.length many elements.
+
+      // Compute the Lagrange coefficients at 0.
+      for (var i = 0; i < shares.length; i++) {
+        for (var share_num = 0; share_num < shares[i].value.length; share_num++) {
+          var pi = jiff.helpers.get_party_number(shares[i].sender_id, share_num);
+          lagrange_coeff[pi] = 1;
+
+          for (var j = 0; j < shares.length; j++) {
+            for (var n = 0; n < shares[j].value.length; n++) {
+              var pj = jiff.helpers.get_party_number(shares[j].sender_id, n);
+              if (pj !== pi) {
+                var inv = jiff.helpers.extended_gcd(pi - pj, shares[i].Zp)[0];
+                lagrange_coeff[pi] = jiff.helpers.mod(lagrange_coeff[pi] * (0 - pj), shares[i].Zp) * inv;
+                lagrange_coeff[pi] = jiff.helpers.mod(lagrange_coeff[pi], shares[i].Zp);
+              }
+            }
+          }
+        }
+      }
+
+      // Reconstruct the secret via Lagrange interpolation
+      var recons_secret = 0;
+      for (var p = 0; p < shares.length; p++) {
+        for (share_num = 0; share_num < shares[p].value.length; share_num++) {
+          var party = jiff.helpers.get_party_number(shares[p].sender_id, share_num);
+          var tmp = jiff.helpers.mod((shares[p].value[share_num] * lagrange_coeff[party]), shares[p].Zp);
+          recons_secret = jiff.helpers.mod((recons_secret + tmp), shares[p].Zp);
+        }
+      }
+      return recons_secret;
+    }
+
+    var old_share = jiff.share;
+    jiff.share = function (secret, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios) {
+      //receivers_ratios = {1: 2, 2: 2};
+      if (receivers_ratios == null){
+        var result = old_share(secret, threshold, receivers_list, senders_list, Zp, share_id);
+        return result;
+      } else {
+        var i, j, p_id, p_ratio;
+
+        // defaults
+        if (Zp == null) {
+          Zp = jiff.Zp;
+        }
+        if (receivers_list == null) {
+          receivers_list = [];
+          for (i = 1; i <= jiff.party_count; i++) {
+            receivers_list.push(i);
+          }
+        }
+        if (senders_list == null) {
+          senders_list = [];
+          for (i = 1; i <= jiff.party_count; i++) {
+            senders_list.push(i);
+          }
+        }
+        if (threshold == null) {
+          threshold = receivers_list.length;
+        }
+        if (threshold < 0) {
+          threshold = 2;
+        }
+        if (threshold > receivers_list.length) {
+          threshold = receivers_list.length;
+        }
+
+        // if party is uninvolved in the share, do nothing
+        if (receivers_list.indexOf(jiff.id) === -1 && senders_list.indexOf(jiff.id) === -1) {
+          return {};
+        }
+
+        // compute operation id
+        receivers_list.sort(); // sort to get the same order
+        senders_list.sort();
+        if (share_id == null) {
+          share_id = jiff.counters.gen_share_id(receivers_list, senders_list);
+        }
+
+        // stage sending of shares
+        if (senders_list.indexOf(jiff.id) > -1) {
+          // Call hook
+          secret = jiff.execute_array_hooks('beforeShare', [jiff, secret, threshold, receivers_list, senders_list, Zp], 1);
+
+          // compute shares
+          var shares = jiff_compute_shares(jiff, secret, receivers_list, threshold, Zp, receivers_ratios);
+
+          // Call hook
+          shares = jiff.execute_array_hooks('afterComputeShare', [jiff, shares, threshold, receivers_list, senders_list, Zp], 1);
+
+          // send shares
+          for (i = 0; i < receivers_list.length; i++) {
+            p_id = receivers_list[i];
+            if (p_id === jiff.id) {
+              continue;
+            }
+
+            // send encrypted and signed shares_id[p_id] to party p_id
+            var msg = { party_id: p_id, share: shares[p_id], op_id: share_id, p_ratio: p_ratio};
+            msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'share', msg], 2);
+            p_ratio = (p_id in receivers_ratios) ? receivers_ratios[p_id] : 1;
+            for (j = 0; j < p_ratio; j++) {
+              msg['share'][j] = jiff.hooks.encryptSign(jiff, msg['share'][j].toString(10), jiff.keymap[msg['party_id']], jiff.secret_key);
+            }
+            jiff.socket.safe_emit('share', JSON.stringify(msg));
+          }
+        }
+
+        // stage receiving of shares
+        var result = {};
+        if (receivers_list.indexOf(jiff.id) > -1) {
+          // setup a map of deferred for every received share
+          if (jiff.deferreds[share_id] == null) {
+            jiff.deferreds[share_id] = {};
+          }
+
+          for (i = 0; i < senders_list.length; i++) {
+            p_id = senders_list[i];
+            p_ratio = (p_id in receivers_ratios) ? receivers_ratios[p_ratio] : 1;
+            if (p_id === jiff.id) {
+              var my_share = jiff.execute_array_hooks('receiveShare', [jiff, p_id, shares[p_id]], 2);
+              result[p_id] = jiff.secret_share(jiff, true, null, my_share, receivers_list, threshold, Zp);
+              continue; // Keep party's own share
+            }
+
+            // check if a deferred is set up (maybe the message was previously received)
+            if (jiff.deferreds[share_id][p_id] == null) {
+              // not ready, setup a deferred
+              jiff.deferreds[share_id][p_id] = new Deferred();
+            }
+
+            var promise = jiff.deferreds[share_id][p_id].promise;
+
+            // destroy deferred when done
+            (function (promise, p_id) { // p_id is modified in a for loop, must do this to avoid scoping issues.
+              promise.then(function () {
+                jiff.deferreds[share_id][p_id] = null;
+              });
+            })(promise, p_id);
+
+            // receive share_i[id] from party p_id
+            result[p_id] = jiff.secret_share(jiff, false, promise, undefined, receivers_list, threshold, Zp, share_id + ':' + p_id);
+          }
+        }
+        return result;
+      }
+    };
+
+    function jiff_compute_shares(jiff, secret, parties_list, threshold, Zp, parties_ratios) {
+      var shares = {}; // Keeps the shares
+      var i;
+      // Each player's random polynomial f must have
+      // degree threshold - 1, so that threshold many points are needed
+      // to interpolate/reconstruct.
+      var t = threshold - 1;
+      var polynomial = Array(t + 1); // stores the coefficients
+
+      // Each players's random polynomial f must be constructed
+      // such that f(0) = secret
+      polynomial[0] = secret;
+
+      // Compute the random polynomial f's coefficients
+      for (i = 1; i <= t; i++) {
+        polynomial[i] = jiff.helpers.random(Zp);
+      }
+
+      // Compute each players share such that share[i] = f(i)
+      for (i = 0; i < parties_list.length; i++) {
+        var p_id = parties_list[i];
+        var p_ratio = p_id in parties_ratios ? parties_ratios[p_id] : 1;
+        shares[p_id] = [];
+        for (var share_num = 0; share_num < p_ratio; share_num++) {
+          shares[p_id][share_num] = polynomial[0];
+          var power = jiff.helpers.get_party_number(p_id, share_num);
+
+          for (var j = 1; j < polynomial.length; j++) {
+            var tmp = jiff.helpers.mod((polynomial[j] * power), Zp);
+            shares[p_id][share_num] = jiff.helpers.mod((shares[p_id][share_num] + tmp), Zp);
+            power = jiff.helpers.mod(power * jiff.helpers.get_party_number(p_id, share_num), Zp);
+          }
+        }
+      }
+      return shares;
+    }
+
+
+    /* HOOKS */
+    jiff.helpers.get_party_number = function (party_id, share_num) {
+      if (share_num == null){
+        share_num = 0;
+      }
+      if (typeof(party_id) === 'number') {
+        return party_id + (share_num * (jiff.party_count+1));
+      }
+      if (party_id.startsWith('s')) {
+        return parseInt(party_id.substring(1), 10) * (jiff.party_count+1); // n+1 reserved for server
+      }
+      return parseInt(party_id, 10) + (share_num * (jiff.party_count+1));
+    };
+
+    jiff.hooks.createSecretShare.push(createMultipleSharesSecretShare);
+    jiff.hooks.afterOperation.push(afterOperationMultipleShares);
+    return jiff;
+  }
+
+  // Expose API
+  exports.make_jiff = make_jiff;
+
+}((typeof exports === 'undefined' ? this.jiff_asynchronousshare = {} : exports), typeof exports !== 'undefined'));
\ No newline at end of file
diff --git a/lib/ext/jiff-client-multipleshares.js b/lib/ext/jiff-client-multipleshares.js
deleted file mode 100644
index dde4bd574..000000000
--- a/lib/ext/jiff-client-multipleshares.js
+++ /dev/null
@@ -1,469 +0,0 @@
-/**
- * @namespace jiff_fixedpoint
- * @version 1.0
- */
-(function (exports, node) {
-  /**
-   * The name of this extension: 'multipleshares'
-   * @type {string}
-   * @memberOf jiff_multipleshares
-   */
-  exports.name = 'multipleshares';
-
-  function createMultipleSharesSecretShare(jiff, share, share_helpers) {
-    share.legacy = {};
-    var internals = ['cadd', 'csub', 'cmult',
-      'sadd', 'ssub', 'smult', 'smult_bgw',
-      'cdivfac', 'cdiv', 'sdiv', 'smod',
-      'cxor_bit', 'sxor_bit', 'cor_bit', 'sor_bit', 'not',
-      'slt', 'slteq', 'sgt', 'sgteq', 'seq', 'sneq',
-      'clt', 'clteq', 'cgt', 'cgteq', 'ceq', 'cneq',
-      'lt_halfprime', 'if_else' ];
-    for (var i = 0; i < internals.length; i++) {
-      var key = internals[i];
-      share.legacy[key] = share[key];
-    }
-    return share;
-  }
-
-  function make_jiff(base_instance, options) {
-    var jiff = base_instance;
-
-    // Parse options
-    if (options == null) {
-      options = {};
-    }
-
-    old_open = jiff.open;
-    jiff.open = function(share, parties, op_ids) {
-      console.log(share, typeof(share.value));
-      if (typeof(share.value) === 'number') {
-        old_open(share, parties, op_ids);
-      } else {
-        var i;
-
-        if (!(share.jiff === jiff)) {
-          throw 'share does not belong to given instance';
-        }
-
-        // Default values
-        if (parties == null || parties === []) {
-          parties = [];
-          for (i = 1; i <= jiff.party_count; i++) {
-            parties.push(i);
-          }
-        } else {
-          parties.sort();
-        }
-
-        // If not a receiver nor holder, do nothing
-        if (share.holders.indexOf(jiff.id) === -1 && parties.indexOf(jiff.id) === -1) {
-          return null;
-        }
-
-        // Compute operation ids (one for each party that will receive a result
-        if (op_ids == null) {
-          op_ids = {};
-        }
-
-        if (typeof (op_ids) === 'string' || typeof (op_ids) === 'number') {
-          var tmp = {};
-          for (i = 0; i < parties.length; i++) {
-            tmp[parties[i]] = op_ids;
-          }
-          op_ids = tmp;
-        } else {
-          var holders_label = share.holders.join(',');
-          for (i = 0; i < parties.length; i++) {
-            if (op_ids[parties[i]] == null) {
-              op_ids[parties[i]] = jiff.counters.gen_open_id(parties[i], holders_label);
-            }
-          }
-        }
-
-        // Party is a holder
-        if (share.holders.indexOf(jiff.id) > -1) {
-          // Call hook
-          share = jiff.execute_array_hooks('beforeOpen', [jiff, share, parties], 1);
-
-          // refresh/reshare, so that the original share remains secret, instead
-          // a new share is sent/open without changing the actual value.
-          share = share.refresh('refresh:' + op_ids[parties[0]]);
-
-          // The given share has been computed, share it to all parties
-          if (share.ready) {
-            jiff_broadcast(jiff, share, parties, op_ids);
-          } else {
-            jiff.counters.pending_opens++;
-            // Share is not ready, setup sharing as a callback to its promise
-            share.promise.then(function () {
-              jiff.counters.pending_opens--;
-              jiff_broadcast(jiff, share, parties, op_ids);
-            }, share.error);
-          }
-        }
-
-        // Party is a receiver
-        if (parties.indexOf(jiff.id) > -1) {
-          var shares = []; // this will store received shares
-          var numberofshares = 0;
-          var final_deferred = new Deferred(); // will be resolved when the final value is reconstructed
-          var final_promise = final_deferred.promise;
-          for (i = 0; i < share.holders.length; i++) {
-            var p_id = share.holders[i];
-
-            // Setup a deferred for receiving a share from party p_id
-            if (jiff.deferreds[op_ids[jiff.id]] == null) {
-              jiff.deferreds[op_ids[jiff.id]] = {};
-            }
-            if (jiff.deferreds[op_ids[jiff.id]][p_id] == null) {
-              jiff.deferreds[op_ids[jiff.id]][p_id] = new Deferred();
-            }
-
-            // Clean up deferred when fulfilled
-            var promise = jiff.deferreds[op_ids[jiff.id]][p_id].promise;
-
-            // destroy deferred when done
-            (function (promise, p_id) { // p_id is modified in a for loop, must do this to avoid scoping issues.
-              promise.then(function (received_share) {
-                jiff.deferreds[op_ids[jiff.id]][p_id] = null;
-                shares.push(received_share);
-                numberofshares += received_share['share'].length;
-
-                // Too few shares, nothing to do.
-                if (numberofshares < share.threshold) {
-                  return;
-                }
-
-                // Enough shares to reconstruct.
-                // If did not already reconstruct, do it.
-                if (final_deferred != null) {
-                  var recons_secret = jiff.hooks.reconstructShare(jiff, shares);
-                  recons_secret = jiff.execute_array_hooks('afterReconstructShare', [jiff, recons_secret], 1);
-
-                  final_deferred.resolve(recons_secret);
-                  final_deferred = null;
-                }
-
-                // If all shares were received, clean up.
-                if (shares.length === share.holders.length) {
-                  shares = null;
-                  jiff.deferreds[op_ids[jiff.id]] = null;
-                }
-              });
-            })(promise, p_id);
-          }
-
-          return final_promise;
-        }
-
-        return null;
-      }
-    }
-
-    function receive_open(jiff, json_msg) {
-      // Decrypt share
-      if (json_msg['party_id'] !== jiff.id) {
-        for (var i = 0; i < json_msg['share'].length; i++) {
-          json_msg['share'][i] = jiff.hooks.decryptSign(jiff, json_msg['share'][i], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
-        }
-        json_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'open', json_msg], 2);
-      }
-
-      var sender_id = json_msg['party_id'];
-      var op_id = json_msg['op_id'];
-      var share = json_msg['share'];
-      var Zp = json_msg['Zp'];
-
-      // call hook
-      share = jiff.execute_array_hooks('receiveOpen', [jiff, sender_id, share, Zp], 2);
-
-      // Resolve the deferred.
-      if (jiff.deferreds[op_id] == null) {
-        jiff.deferreds[op_id] = {};
-      }
-      if (jiff.deferreds[op_id][sender_id] == null) {
-        jiff.deferreds[op_id][sender_id] = new Deferred();
-      }
-
-      jiff.deferreds[op_id][sender_id].resolve({value: share, sender_id: sender_id, Zp: Zp});
-    }
-
-    function jiff_broadcast(jiff, share, parties, op_ids) {
-      for (var index = 0; index < parties.length; index++) {
-        var i = parties[index]; // Party id
-        if (i === jiff.id) {
-          receive_open(jiff, {party_id: i, share: share.value, op_id: op_ids[i], Zp: share.Zp});
-          continue;
-        }
-
-        // encrypt, sign and send
-        var msg = {party_id: i, share: share.value, op_id: op_ids[i], Zp: share.Zp};
-        msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'open', msg], 2);
-
-        for (var j = 0; j < msg['share'].length; j++) {
-          msg['share'][j] = jiff.hooks.encryptSign(jiff, msg['share'][j].toString(), jiff.keymap[msg['party_id']], jiff.secret_key);
-        }
-        jiff.socket.safe_emit('open', JSON.stringify(msg));
-      }
-    }
-
-    function jiff_lagrange(jiff, shares) {
-      var lagrange_coeff = []; // will contain shares.length many elements.
-
-      // Compute the Langrange coefficients at 0.
-      for (var i = 0; i < shares.length; i++) {
-        var pi = jiff.helpers.get_party_number(shares[i].sender_id);
-        lagrange_coeff[pi] = 1;
-
-        for (var j = 0; j < shares.length; j++) {
-          var pj = jiff.helpers.get_party_number(shares[j].sender_id);
-          if (pj !== pi) {
-            var inv = jiff.helpers.extended_gcd(pi - pj, shares[i].Zp)[0];
-            lagrange_coeff[pi] = jiff.helpers.mod(lagrange_coeff[pi] * (0 - pj), shares[i].Zp) * inv;
-            lagrange_coeff[pi] = jiff.helpers.mod(lagrange_coeff[pi], shares[i].Zp);
-          }
-        }
-      }
-
-      // Reconstruct the secret via Lagrange interpolation
-      var recons_secret = 0;
-      for (var p = 0; p < shares.length; p++) {
-        var party = jiff.helpers.get_party_number(shares[p].sender_id);
-        var tmp = jiff.helpers.mod((shares[p].value * lagrange_coeff[party]), shares[p].Zp);
-        recons_secret = jiff.helpers.mod((recons_secret + tmp), shares[p].Zp);
-      }
-
-      return recons_secret;
-    }
-
-    var old_share = jiff.share;
-    jiff.share = function (secret, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios) {
-      receivers_ratios = {};
-      for (var i = 1; i <= jiff.party_count; i++) {
-        receivers_ratios[i] = 2;
-      }
-      if (receivers_ratios == null){
-        var result = old_share(secret, threshold, receivers_list, senders_list, Zp, share_id);
-        return result;
-      }
-      else{
-        var i, j, p_id, p_ratio;
-
-        // defaults
-        if (Zp == null) {
-          Zp = jiff.Zp;
-        }
-        if (receivers_list == null) {
-          receivers_list = [];
-          for (i = 1; i <= jiff.party_count; i++) {
-            receivers_list.push(i);
-          }
-        }
-        if (senders_list == null) {
-          senders_list = [];
-          for (i = 1; i <= jiff.party_count; i++) {
-            senders_list.push(i);
-          }
-        }
-        if (threshold == null) {
-          threshold = receivers_list.length;
-        }
-        if (threshold < 0) {
-          threshold = 2;
-        }
-        if (threshold > receivers_list.length) {
-          threshold = receivers_list.length;
-        }
-
-        // if party is uninvolved in the share, do nothing
-        if (receivers_list.indexOf(jiff.id) === -1 && senders_list.indexOf(jiff.id) === -1) {
-          return {};
-        }
-
-        // compute operation id
-        receivers_list.sort(); // sort to get the same order
-        senders_list.sort();
-        if (share_id == null) {
-          share_id = jiff.counters.gen_share_id(receivers_list, senders_list);
-        }
-
-        // stage sending of shares
-        if (senders_list.indexOf(jiff.id) > -1) {
-          // Call hook
-          secret = jiff.execute_array_hooks('beforeShare', [jiff, secret, threshold, receivers_list, senders_list, Zp], 1);
-
-          // compute shares
-          var shares = jiff_compute_shares(jiff, secret, receivers_list, threshold, Zp, receivers_ratios);
-
-          // Call hook
-          shares = jiff.execute_array_hooks('afterComputeShare', [jiff, shares, threshold, receivers_list, senders_list, Zp], 1);
-
-          // send shares
-          for (i = 0; i < receivers_list.length; i++) {
-            p_id = receivers_list[i];
-            if (p_id === jiff.id) {
-              continue;
-            }
-
-            // send encrypted and signed shares_id[p_id] to party p_id
-            var msg = { party_id: p_id, share: shares[p_id], op_id: share_id, p_ratio: p_ratio};
-            msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'share', msg], 2);
-            p_ratio = (p_id in receivers_ratios) ? receivers_ratios[p_id] : 1;
-            for (j = 0; j < p_ratio; j++) {
-              msg['share'][j] = jiff.hooks.encryptSign(jiff, msg['share'][j].toString(10), jiff.keymap[msg['party_id']], jiff.secret_key);
-            }
-            jiff.socket.safe_emit('share', JSON.stringify(msg));
-          }
-        }
-
-        // stage receiving of shares
-        var result = {};
-        if (receivers_list.indexOf(jiff.id) > -1) {
-          // setup a map of deferred for every received share
-          if (jiff.deferreds[share_id] == null) {
-            jiff.deferreds[share_id] = {};
-          }
-
-          for (i = 0; i < senders_list.length; i++) {
-            p_id = senders_list[i];
-            p_ratio = (p_id in receivers_ratios) ? receivers_ratios[p_ratio] : 1;
-            if (p_id === jiff.id) {
-              var my_share = jiff.execute_array_hooks('receiveShare', [jiff, p_id, shares[p_id]], 2);
-              result[p_id] = jiff.secret_share(jiff, true, null, my_share, receivers_list, threshold, Zp);
-              continue; // Keep party's own share
-            }
-
-            // check if a deferred is set up (maybe the message was previously received)
-            if (jiff.deferreds[share_id][p_id] == null) {
-              // not ready, setup a deferred
-              jiff.deferreds[share_id][p_id] = new Deferred();
-            }
-
-            var promise = jiff.deferreds[share_id][p_id].promise;
-
-            // destroy deferred when done
-            (function (promise, p_id) { // p_id is modified in a for loop, must do this to avoid scoping issues.
-              promise.then(function () {
-                jiff.deferreds[share_id][p_id] = null;
-              });
-            })(promise, p_id);
-
-            // receive share_i[id] from party p_id
-            result[p_id] = jiff.secret_share(jiff, false, promise, undefined, receivers_list, threshold, Zp, share_id + ':' + p_id);
-          }
-        }
-        return result;
-      }
-    }
-
-    function jiff_compute_shares(jiff, secret, parties_list, threshold, Zp, parties_ratios) {
-      var shares = {}; // Keeps the shares
-      var i;
-
-      // Each player's random polynomial f must have
-      // degree threshold - 1, so that threshold many points are needed
-      // to interpolate/reconstruct.
-      var t = threshold - 1;
-      var polynomial = Array(t + 1); // stores the coefficients
-
-      // Each players's random polynomial f must be constructed
-      // such that f(0) = secret
-      polynomial[0] = secret;
-
-      // Compute the random polynomial f's coefficients
-      for (i = 1; i <= t; i++) {
-        polynomial[i] = jiff.helpers.random(Zp);
-      }
-
-      // Compute each players share such that share[i] = f(i)
-      for (i = 0; i < parties_list.length; i++) {
-        var p_id = parties_list[i];
-        var p_ratio = p_id in parties_ratios ? parties_ratios[p_id] : 1;
-        shares[p_id] = [];
-        for (var share_num = 0; share_num < p_ratio; share_num++) {
-          shares[p_id][share_num] = polynomial[0];
-          var power = jiff.helpers.get_party_number(p_id, share_num);
-
-          for (var j = 1; j < polynomial.length; j++) {
-            var tmp = jiff.helpers.mod((polynomial[j] * power), Zp);
-            shares[p_id][share_num] = jiff.helpers.mod((shares[p_id][share_num] + tmp), Zp);
-            power = jiff.helpers.mod(power * jiff.helpers.get_party_number(p_id, share_num), Zp);
-          }
-        }
-      }
-      return shares;
-    }
-
-    function receive_share(jiff, json_msg) {
-      // Decrypt share
-      var num_shares = json_msg['share'].length;
-      for (var i = 0; i < num_shares; i++) {
-        json_msg['share'][i] = jiff.hooks.decryptSign(jiff, json_msg['share'][i], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
-      }
-
-      // change afterOperation hook to handle array of shares
-      jiff.hooks.afterOperation = (function (jiff, label, msg) {
-        if (label === 'share' || label === 'open') {
-          for (var i = 0; i < msg['share'].length; i++) {
-            msg['share'][i] = parseInt(msg['share'][i], 10);
-          }
-        }
-        return msg;
-      });
-      json_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'share', json_msg], 2);
-
-      var sender_id = json_msg['party_id'];
-      var op_id = json_msg['op_id'];
-      var share = json_msg['share'];
-
-      // Call hook
-      share = jiff.execute_array_hooks('receiveShare', [jiff, sender_id, share], 2);
-
-      // check if a deferred is set up (maybe the share was received early)
-      if (jiff.deferreds[op_id] == null) {
-        jiff.deferreds[op_id] = {};
-      }
-      if (jiff.deferreds[op_id][sender_id] == null) {
-        // Share is received before deferred was setup, store it.
-        jiff.deferreds[op_id][sender_id] = new Deferred();
-      }
-
-      // Deferred is already setup, resolve it.
-      jiff.deferreds[op_id][sender_id].resolve(share);
-    }
-
-    function Deferred() {
-      // Polyfill for jQuery Deferred
-      // From https://developer.mozilla.org/en-US/docs/Mozilla/JavaScript_code_modules/Promise.jsm/Deferred
-      this.resolve = null;
-
-      /* A method to reject the associated Promise with the value passed.
-       * If the promise is already settled it does nothing.
-       *
-       * @param {anything} reason: The reason for the rejection of the Promise.
-       * Generally its an Error object. If however a Promise is passed, then the Promise
-       * itself will be the reason for rejection no matter the state of the Promise.
-       */
-      this.reject = null;
-
-      /* A newly created Promise object.
-       * Initially in pending state.
-       */
-      this.promise = new Promise(function (resolve, reject) {
-        this.resolve = resolve;
-        this.reject = reject;
-      }.bind(this));
-      Object.freeze(this);
-    }
-
-    /* HOOKS */
-    jiff.hooks.createSecretShare.push(createMultipleSharesSecretShare);
-
-    return jiff;
-  }
-
-  // Expose API
-  exports.make_jiff = make_jiff;
-
-}((typeof exports === 'undefined' ? this.jiff_multipleshares = {} : exports), typeof exports !== 'undefined'));
\ No newline at end of file
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index 18768c830..8807d0b5d 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -351,9 +351,15 @@
    */
   function receive_share(jiff, json_msg) {
     // Decrypt share
-    json_msg['share'] = jiff.hooks.decryptSign(jiff, json_msg['share'], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
-    json_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'share', json_msg], 2);
+    if (json_msg['share'].length >= 1) {
+      for (var i = 0; i < json_msg['share'].length; i++) {
+        json_msg['share'][i] = jiff.hooks.decryptSign(jiff, json_msg['share'][i], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
+      }
+    } else {
+      json_msg['share'] = jiff.hooks.decryptSign(jiff, json_msg['share'], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
+    }
 
+    json_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'share', json_msg], 2);
     var sender_id = json_msg['party_id'];
     var op_id = json_msg['op_id'];
     var share = json_msg['share'];
@@ -472,7 +478,7 @@
           promise.then(function (received_share) {
             jiff.deferreds[op_ids[jiff.id]][p_id] = null;
             shares.push(received_share);
-            console.log(shares);
+
             // Too few shares, nothing to do.
             if (shares.length < share.threshold) {
               return;
@@ -483,7 +489,6 @@
             if (final_deferred != null) {
               var recons_secret = jiff.hooks.reconstructShare(jiff, shares);
               recons_secret = jiff.execute_array_hooks('afterReconstructShare', [jiff, recons_secret], 1);
-
               final_deferred.resolve(recons_secret);
               final_deferred = null;
             }
@@ -539,7 +544,13 @@
   function receive_open(jiff, json_msg) {
     // Decrypt share
     if (json_msg['party_id'] !== jiff.id) {
-      json_msg['share'] = jiff.hooks.decryptSign(jiff, json_msg['share'], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
+      if (json_msg['share'].length >= 1) {
+        for (var i = 0; i < json_msg['share'].length; i++) {
+          json_msg['share'][i] = jiff.hooks.decryptSign(jiff, json_msg['share'][i], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
+        }
+      } else {
+        json_msg['share'] = jiff.hooks.decryptSign(jiff, json_msg['share'], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
+      }
       json_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'open', json_msg], 2);
     }
 
@@ -597,7 +608,6 @@
       var tmp = jiff.helpers.mod((shares[p].value * lagrange_coeff[party]), shares[p].Zp);
       recons_secret = jiff.helpers.mod((recons_secret + tmp), shares[p].Zp);
     }
-
     return recons_secret;
   }
 
@@ -2020,6 +2030,7 @@
         } else {
           // Resolve the deferred when ready.
           final_result.promise.then(function () {
+            console.log(final_result.value);
             final_deferred.resolve(final_result.value);
           });
         }
@@ -2673,6 +2684,7 @@
           one_bit(i + 1);
         });
       })(0);
+      console.log('sdiv', final_promise);
       return result;
     };
 

From 2c7d22e159c5e7f54061c0d0df3b7fe7fc32b7de Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Mon, 1 Jul 2019 13:04:03 -0400
Subject: [PATCH 04/24] arithmetic operations

---
 demos/multipleshares/mpc.js              |   4 +-
 lib/ext/jiff-client-asynchronousshare.js | 718 ++++++++++++++++-------
 lib/jiff-client.js                       |   2 -
 3 files changed, 512 insertions(+), 212 deletions(-)

diff --git a/demos/multipleshares/mpc.js b/demos/multipleshares/mpc.js
index 33ad9b949..3d894363b 100644
--- a/demos/multipleshares/mpc.js
+++ b/demos/multipleshares/mpc.js
@@ -34,9 +34,9 @@
     var sum = shares[1];
 
     for (var i = 2; i <= jiff_instance.party_count; i++) {
-      sum = sum.sdiv(shares[i]);
+      sum = sum.smult(shares[i]);
     }
-    console.log(sum);
+
     // Return a promise to the final output(s)
     var result = jiff_instance.open(sum);
     return result;
diff --git a/lib/ext/jiff-client-asynchronousshare.js b/lib/ext/jiff-client-asynchronousshare.js
index b61088c5f..06167ff30 100644
--- a/lib/ext/jiff-client-asynchronousshare.js
+++ b/lib/ext/jiff-client-asynchronousshare.js
@@ -6,7 +6,7 @@
   /**
    * The name of this extension: 'multipleshares'
    * @type {string}
-   * @memberOf jiff_multipleshares
+   * @memberOf jiff_asynchronousshare
    */
   exports.name = 'asynchronousshare';
 
@@ -54,18 +54,19 @@
     }
 
     share.cadd = function (o) {
+      var result, addshare;
       var ready_add = function () {
         if (!(share.isConstant(o))) {
           throw new Error('parameter should be a number (+)');
         }
         var result = [];
         for (var i = 0; i < share.value.length; i++) {
-          result.push(jiff.helpers.mod(share_helpers['+'](share.value[i], o), share.Zp));
+            result.push(jiff.helpers.mod(share_helpers['+'](share.value[i], o), share.Zp));
         }
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
           return share.legacy.cadd(o);
         } else {
@@ -73,9 +74,16 @@
         }
       }
 
-      var promise = share.promise.then( function () {
+      var promise = share.promise.then(function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cadd(o).value;
+          addshare = share.legacy.cadd(o);
+          if (addshare.ready) {
+            return addshare.value;
+          }
+          result = addshare.promise.then(function () {
+            return addshare.value;
+          });
+          return result;
         } else {
           return ready_add();
         }
@@ -117,12 +125,11 @@
           addshare = share.legacy.sadd(o);
           if (addshare.ready) {
             return addshare.value;
-          } else {
-            result = addshare.promise.then(function () {
-              return addshare.value;
-            });
-            return result;
           }
+          result = addshare.promise.then(function () {
+            return addshare.value;
+          });
+          return result;
         } else {
           return ready_add();
         }
@@ -131,15 +138,16 @@
     };
 
     share.csub = function (o) {
+      var result, subshare;
       var ready_sub = function () {
-        var result = [];
+        result = [];
         for (var i = 0; i < share.value.length; i++) {
           result.push(jiff.helpers.mod(share_helpers['-'](share.value[i], o), share.Zp));
         }
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
           return share.legacy.csub(o);
         } else {
@@ -149,7 +157,14 @@
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.csub(o).value;
+          subshare = share.legacy.csub(o);
+          if (subshare.ready) {
+            return subshare.value;
+          }
+          result = subshare.promise.then(function () {
+            return subshare.value;
+          });
+          return result;
         } else {
           return ready_sub();
         }
@@ -171,7 +186,7 @@
           throw new Error('shares must be held by the same parties (+)');
         }
 
-        var result = [];
+        result = [];
         for (var i = 0; i < share.value.length; i++) {
           result.push(share.jiff.helpers.mod(share_helpers['-'](share.value[i], o.value[i]), share.Zp));
         }
@@ -192,12 +207,11 @@
           subshare = share.legacy.ssub(o);
           if (subshare.ready) {
             return subshare.value;
-          } else {
-            result = subshare.promise.then(function () {
-              return subshare.value;
-            });
-            return result;
           }
+          result = subshare.promise.then(function () {
+            return subshare.value;
+          });
+          return result;
         } else {
           return ready_sub();
         }
@@ -206,19 +220,20 @@
     };
 
     share.cmult = function (o) {
+      var result, multshare;
       var ready_mult = function () {
         if (!(share.isConstant(o))) {
           throw new Error('parameter should be a number (*)');
         }
 
-        var result = [];
+        result = [];
         for (var i = 0; i < share.value.length; i++) {
           result.push(jiff.helpers.mod(share_helpers['*'](share.value[i], o), share.Zp));
         }
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
           return share.legacy.cmult(o);
         } else {
@@ -228,7 +243,14 @@
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cmult(o).value;
+          multshare = share.legacy.cmult(o);
+          if (multshare.ready) {
+            return multshare.value;
+          }
+          result = multshare.promise.then(function () {
+            return multshare.value;
+          });
+          return result;
         } else {
           return ready_mult();
         }
@@ -248,7 +270,7 @@
           o.value = o_val[i];
           multshare = share.legacy.smult(o, op_id);
           if (multshare.ready) {
-            return multshare.value;
+            result.push(multshare.value);
           } else {
             multshare.promise.then(function () {
               result.push(multshare.value);
@@ -274,12 +296,11 @@
           multshare = share.legacy.smult(o);
           if (multshare.ready) {
             return multshare.value;
-          } else {
-            result = multshare.promise.then(function () {
-            return multshare.value;
-            });
-            return result;
           }
+          result = multshare.promise.then(function () {
+            return multshare.value;
+          });
+          return result;
         } else {
           return ready_mult();
         }
@@ -300,7 +321,7 @@
           o.value = o_val[i];
           multshare = share.legacy.smult_bgw(o, op_id);
           if (multshare.ready) {
-            return multshare.value;
+            result.push(multshare.value);
           } else {
             multshare.promise.then(function () {
               result.push(multshare.value);
@@ -323,15 +344,14 @@
       // promise to execute ready_add when both are ready
       var promise = share.pick_promise(o).then( function () {
         if (typeof (share.value) === 'number') {
-          multshare = share.legacy.smult_bgw(o);
+          multshare = share.legacy.smult_bgw(o, op_id);
           if (multshare.ready) {
             return multshare.value;
-          } else {
-            result = multshare.promise.then(function () {
-              return multshare.value;
-            });
-            return result;
           }
+          result = multshare.promise.then(function () {
+            return multshare.value;
+          });
+          return result;
         } else {
           return ready_mult_bgw();
         }
@@ -340,20 +360,29 @@
     };
 
     share.cdiv = function (o, op_id) {
+      var result, divshare;
+
       var ready_div = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          result.push(share.legacy.cdiv(o, op_id).value);
+          divshare = share.legacy.cdiv(o, op_id);
+          if (divshare.ready) {
+            result.push(divshare.value);
+          } else {
+            divshare.promise.then(function () {
+              result.push(divshare.value);
+            });
+          }
         }
         share.value = share_val;
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cdiv(o, op_id).value;
+          return share.legacy.cdiv(o, op_id);
         } else {
           return share.jiff.secret_share(share.jiff, true, null, ready_div(), share.holders, share.threshold, share.Zp);
         }
@@ -361,7 +390,14 @@
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cdiv(o, op_id).value;
+          divshare = share.legacy.cdiv(o);
+          if (divshare.ready) {
+            return divshare.value;
+          }
+          result = divshare.promise.then(function () {
+            return divshare.value;
+          });
+          return result;
         } else {
           return ready_div();
         }
@@ -370,37 +406,52 @@
     };
 
     share.cdivfac = function (o) {
-      var ready_div = function () {
-        var result = [];
+      var result, divshare;
+
+      var ready_divfac = function () {
+        result = [];
         var share_val = share.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          result.push(share.legacy.cdivfac(o).value);
+          divshare = share.legacy.cdivfac(o);
+          if (divshare.ready) {
+            result.push(divshare.value);
+          } else {
+            divshare.promise.then(function () {
+              result.push(divshare.value);
+            });
+          }
         }
         share.value = share_val;
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cdivfac(o).value;
+          return share.legacy.cdivfac(o);
         } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_div(), share.holders, share.threshold, share.Zp);
+          return share.jiff.secret_share(share.jiff, true, null, ready_divfac(), share.holders, share.threshold, share.Zp);
         }
       }
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cdivfac(o).value;
+          divshare = share.legacy.cdivfac(o);
+          if (divshare.ready) {
+            return divshare.value;
+          }
+          result = divshare.promise.then(function () {
+            return divshare.value;
+          });
+          return result;
         } else {
-          return ready_div();
+          return ready_divfac();
         }
       }, share.error);
       return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
     };
 
     share.sdiv = function (o, l, op_id) {
-      console.log(share, o);
       var result, divshare;
 
       var ready_div = function () {
@@ -412,7 +463,7 @@
           o.value = o_val[i];
           divshare = share.legacy.sdiv(o, l, op_id);
           if (divshare.ready) {
-            return divshare.value;
+            result.push(divshare.value);
           } else {
             divshare.promise.then(function () {
               result.push(divshare.value);
@@ -435,14 +486,11 @@
       // promise to execute ready_add when both are ready
       var promise = share.pick_promise(o).then( function () {
         if (typeof (share.value) === 'number') {
-          console.log(o);
           divshare = share.legacy.sdiv(o, l, op_id);
-          console.log(divshare);
           if (divshare.ready) {
             return divshare.value;
           }
           result = divshare.promise.then(function () {
-            console.log(divshare);
             return divshare.value;
           });
           return result;
@@ -454,17 +502,23 @@
     };
 
     share.smod = function (o, l, op_id) {
-      var mult_deferred = new Deferred();
-      var finalpromise = mult_deferred.promise;
+      var result, modshare;
 
       var ready_mod = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         var o_val = o.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
           o.value = o_val[i];
-          result.push(share.legacy.smod(o, l, op_id).value);
+          modshare = share.legacy.smod(o, l, op_id);
+          if (modshare.ready) {
+            result.push(modshare.value);
+          } else {
+            modshare.promise.then(function () {
+              result.push(modshare.value);
+            });
+          }
         }
         share.value = share_val;
         o.value = o_val;
@@ -480,34 +534,46 @@
       }
 
       // promise to execute ready_add when both are ready
-      share.pick_promise(o).then( function () {
+      var promise = share.pick_promise(o).then( function () {
         if (typeof (share.value) === 'number') {
-          var result = share.legacy.smod(o, l, op_id);
-          result.promise.then(function () {
-            mult_deferred.resolve(result.value);
+          modshare = share.legacy.smod(o, l, op_id);
+          if (modshare.ready) {
+            return modshare.value;
+          }
+          result = modshare.promise.then(function () {
+            return modshare.value;
           });
+          return result;
         } else {
-          mult_deferred.resolve(ready_mod());
+          return ready_mod();
         }
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
     share.cxor_bit = function (o) {
+      var result, xor_share;
       var ready_xor_bit = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          result.push(share.legacy.cxor_bit(o).value);
+          xor_share = share.legacy.cxor_bit(o);
+          if (xor_share.ready) {
+            result.push(xor_share.value);
+          } else {
+            xor_share.promise.then(function () {
+              result.push(xor_share.value);
+            });
+          }
         }
         share.value = share_val;
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cxor_bit(o).value;
+          return share.legacy.cxor_bit(o);
         } else {
           return share.jiff.secret_share(share.jiff, true, null, ready_xor_bit(), share.holders, share.threshold, share.Zp);
         }
@@ -515,7 +581,14 @@
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cxor_bit(o).value;
+          xor_share = share.legacy.cxor_bit(o);
+          if (xor_share.ready) {
+            return xor_share.value;
+          }
+          result = xor_share.promise.then(function () {
+            return xor_share.value;
+          });
+          return result;
         } else {
           return ready_xor_bit();
         }
@@ -524,17 +597,22 @@
     };
 
     share.sxor_bit = function (o, op_id) {
-      var mult_deferred = new Deferred();
-      var finalpromise = mult_deferred.promise;
-
+      var result, xor_share;
       var ready_xor_bit = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         var o_val = o.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
           o.value = o_val[i];
-          result.push(share.legacy.sxor_bit(o, op_id).value);
+          xor_share = share.legacy.sxor_bit(o, op_id);
+          if (xor_share.ready) {
+            result.push(xor_share.value);
+          } else {
+            xor_share.promise.then(function () {
+              result.push(xor_share.value);
+            });
+          }
         }
         share.value = share_val;
         o.value = o_val;
@@ -550,32 +628,44 @@
       }
 
       // promise to execute ready_add when both are ready
-      share.pick_promise(o).then( function () {
+      var promise = share.pick_promise(o).then( function () {
         if (typeof (share.value) === 'number') {
-          var result = share.legacy.sxor_bit(o, op_id);
-          result.promise.then(function () {
-            mult_deferred.resolve(result.value);
+          xor_share = share.legacy.sxor_bit(o, op_id);
+          if (xor_share.ready) {
+            return xor_share.value;
+          }
+          result = xor_share.promise.then(function () {
+            return xor_share.value;
           });
+          return result;
         } else {
-          mult_deferred.resolve(ready_xor_bit());
+          return ready_xor_bit();
         }
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
     share.cor_bit = function (o) {
+      var result, or_share;
       var ready_or_bit = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          result.push(share.legacy.cor_bit(o).value);
+          or_share = share.legacy.cor_bit(o);
+          if (or_share.ready) {
+            result.push(or_share.value);
+          } else {
+            or_share.promise.then(function () {
+              result.push(or_share.value);
+            });
+          }
         }
         share.value = share_val;
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
           return share.legacy.cor_bit(o).value;
         } else {
@@ -585,7 +675,14 @@
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cor_bit(o).value;
+          or_share = share.legacy.cor_bit(o);
+          if (or_share.ready) {
+            return or_share.value;
+          }
+          result = or_share.promise.then(function () {
+            return or_share.value;
+          });
+          return result;
         } else {
           return ready_or_bit();
         }
@@ -594,17 +691,23 @@
     };
 
     share.sor_bit = function (o, op_id) {
-      var mult_deferred = new Deferred();
-      var finalpromise = mult_deferred.promise;
+      var result, or_share;
 
       var ready_or_bit = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         var o_val = o.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
           o.value = o_val[i];
-          result.push(share.legacy.sor_bit(o, op_id).value);
+          or_share = share.legacy.sor_bit(o, op_id);
+          if (or_share.ready) {
+            result.push(or_share.value);
+          } else {
+            or_share.promise.then(function () {
+              result.push(or_share.value);
+            });
+          }
         }
         share.value = share_val;
         o.value = o_val;
@@ -620,34 +723,46 @@
       }
 
       // promise to execute ready_add when both are ready
-      share.pick_promise(o).then( function () {
+      var promise = share.pick_promise(o).then( function () {
         if (typeof (share.value) === 'number') {
-          var result = share.legacy.sor_bit(o, op_id);
-          result.promise.then(function () {
-            mult_deferred.resolve(result.value);
+          or_share = share.legacy.sor_bit(o, op_id);
+          if (or_share.ready) {
+            return or_share.value;
+          }
+          result = or_share.promise.then(function () {
+            return or_share.value;
           });
+          return result;
         } else {
-          mult_deferred.resolve(ready_or_bit());
+          return ready_or_bit();
         }
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
     share.clt = function (o, op_id) {
+      var result, lt_share;
       var ready_lt = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          result.push(share.legacy.clt(o, op_id).value);
+          lt_share = share.legacy.clt(o, op_id);
+          if (lt_share.ready) {
+            result.push(lt_share.value);
+          } else {
+            lt_share.promise.then(function () {
+              result.push(lt_share.value);
+            });
+          }
         }
         share.value = share_val;
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
-          return share.legacy.clt(o, op_id).value;
+          return share.legacy.clt(o, op_id);
         } else {
           return share.jiff.secret_share(share.jiff, true, null, ready_lt(), share.holders, share.threshold, share.Zp);
         }
@@ -655,7 +770,14 @@
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.clt(o, op_id).value;
+          lt_share = share.legacy.clt(o);
+          if (lt_share.ready) {
+            return lt_share.value;
+          }
+          result = lt_share.promise.then(function () {
+            return lt_share.value;
+          });
+          return result;
         } else {
           return ready_lt();
         }
@@ -664,50 +786,73 @@
     };
 
     share.clteq = function (o, op_id) {
+      var result, lteq_share;
       var ready_lteq = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          result.push(share.legacy.clteq(o, op_id).value);
+          lteq_share = share.legacy.clteq(o, op_id);
+          if (lteq_share.ready) {
+            result.push(lteq_share.value);
+          } else {
+            lteq_share.promise.then(function () {
+              result.push(lteq_share.value);
+            });
+          }
         }
         share.value = share_val;
         return result;
-      };
+        };
 
-      if (share.ready && o.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.clteq(o, op_id).value;
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_lteq(), share.holders, share.threshold, share.Zp);
+        if (share.ready) {
+          if (typeof (share.value) === 'number') {
+            return share.legacy.clteq(o, op_id);
+          } else {
+            return share.jiff.secret_share(share.jiff, true, null, ready_lteq(), share.holders, share.threshold, share.Zp);
+          }
         }
-      }
 
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.clteq(o, op_id).value;
-        } else {
-          return ready_lteq();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+        var promise = share.promise.then( function () {
+          if (typeof (share.value) === 'number') {
+            lteq_share = share.legacy.clteq(o);
+            if (lteq_share.ready) {
+              return lteq_share.value;
+            }
+            result = lteq_share.promise.then(function () {
+              return lteq_share.value;
+            });
+            return result;
+          } else {
+            return ready_lteq();
+          }
+        }, share.error);
+        return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
     };
 
     share.cgt = function (o, op_id) {
+      var result, gt_share;
       var ready_gt = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          result.push(share.legacy.cgt(o, op_id).value);
+          gt_share = share.legacy.cgt(o, op_id);
+          if (gt_share.ready) {
+            result.push(gt_share.value);
+          } else {
+            gt_share.promise.then(function () {
+              result.push(gt_share.value);
+            });
+          }
         }
         share.value = share_val;
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cgt(o, op_id).value;
+          return share.legacy.cgt(o, op_id);
         } else {
           return share.jiff.secret_share(share.jiff, true, null, ready_gt(), share.holders, share.threshold, share.Zp);
         }
@@ -715,29 +860,44 @@
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cgt(o, op_id).value;
+          gt_share = share.legacy.cgt(o, op_id);
+          if (gt_share.ready) {
+            return gt_share.value;
+          }
+          result = gt_share.promise.then(function () {
+            return gt_share.value;
+          });
+          return result;
         } else {
           return ready_gt();
         }
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+        return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
     };
 
     share.cgteq = function (o, op_id) {
+      var result, gteq_share;
       var ready_gteq = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          result.push(share.legacy.cgteq(o, op_id).value);
+          gteq_share = share.legacy.cgteq(o, op_id);
+          if (gteq_share.ready) {
+            result.push(gteq_share.value);
+          } else {
+            gteq_share.promise.then(function () {
+              result.push(gteq_share.value);
+            });
+          }
         }
         share.value = share_val;
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cgteq(o, op_id).value;
+          return share.legacy.cgteq(o, op_id);
         } else {
           return share.jiff.secret_share(share.jiff, true, null, ready_gteq(), share.holders, share.threshold, share.Zp);
         }
@@ -745,7 +905,14 @@
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cgteq(o, op_id).value;
+          gteq_share = share.legacy.cgteq(o, op_id);
+          if (gteq_share.ready) {
+            return gteq_share.value;
+          }
+          result = gteq_share.promise.then(function () {
+            return gteq_share.value;
+          });
+          return result;
         } else {
           return ready_gteq();
         }
@@ -754,20 +921,28 @@
     };
 
     share.ceq = function (o, op_id) {
+      var result, eq_share;
       var ready_eq = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          result.push(share.legacy.ceq(o, op_id).value);
+          eq_share = share.legacy.ceq(o, op_id);
+          if (eq_share.ready) {
+            result.push(eq_share.value);
+          } else {
+            eq_share.promise.then(function () {
+              result.push(eq_share.value);
+            });
+          }
         }
         share.value = share_val;
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
-          return share.legacy.ceq(o, op_id).value;
+          return share.legacy.ceq(o, op_id);
         } else {
           return share.jiff.secret_share(share.jiff, true, null, ready_eq(), share.holders, share.threshold, share.Zp);
         }
@@ -775,7 +950,14 @@
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.ceq(o, op_id).value;
+          eq_share = share.legacy.ceq(o, op_id);
+          if (eq_share.ready) {
+            return eq_share.value;
+          }
+          result = eq_share.promise.then(function () {
+            return eq_share.value;
+          });
+          return result;
         } else {
           return ready_eq();
         }
@@ -784,18 +966,26 @@
     };
 
     share.cneq = function (o, op_id) {
+      var result, neq_share;
       var ready_neq = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          result.push(share.legacy.cneq(o, op_id).value);
+          neq_share = share.legacy.cneq(o, op_id);
+          if (neq_share.ready) {
+            result.push(neq_share.value);
+          } else {
+            neq_share.promise.then(function () {
+              result.push(neq_share.value);
+            });
+          }
         }
         share.value = share_val;
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
           return share.legacy.cneq(o, op_id).value;
         } else {
@@ -805,7 +995,14 @@
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cneq(o, op_id).value;
+          neq_share = share.legacy.cneq(o, op_id);
+          if (neq_share.ready) {
+            return neq_share.value;
+          }
+          result = neq_share.promise.then(function () {
+            return neq_share.value;
+          });
+          return result;
         } else {
           return ready_neq();
         }
@@ -814,17 +1011,23 @@
     };
 
     share.slt = function (o, op_id) {
-      var mult_deferred = new Deferred();
-      var finalpromise = mult_deferred.promise;
+      var result, lt_share;
 
       var ready_lt = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         var o_val = o.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
           o.value = o_val[i];
-          result.push(share.legacy.slt(o, op_id).value);
+          lt_share = share.legacy.slt(o, op_id);
+          if (lt_share.ready) {
+            result.push(lt_share.value);
+          } else {
+            lt_share.promise.then(function () {
+              result.push(lt_share.value);
+            });
+          }
         }
         share.value = share_val;
         o.value = o_val;
@@ -840,31 +1043,41 @@
       }
 
       // promise to execute ready_add when both are ready
-      share.pick_promise(o).then( function () {
+      var promise = share.pick_promise(o).then( function () {
         if (typeof (share.value) === 'number') {
-          var result = share.legacy.slt(o, op_id);
-          result.promise.then(function () {
-            mult_deferred.resolve(result.value);
+          lt_share = share.legacy.slt(o, op_id);
+          if (lt_share.ready) {
+            return lt_share.value;
+          }
+          result = lt_share.promise.then(function () {
+            return lt_share.value;
           });
+          return result;
         } else {
-          mult_deferred.resolve(ready_lt());
+          ready_lt();
         }
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
     share.slteq = function (o, op_id) {
-      var mult_deferred = new Deferred();
-      var finalpromise = mult_deferred.promise;
+      var result, lteq_share;
 
       var ready_lteq = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         var o_val = o.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
           o.value = o_val[i];
-          result.push(share.legacy.slteq(o, op_id).value);
+          lteq_share = share.legacy.slteq(o, op_id);
+          if (lteq_share.ready) {
+            result.push(lteq_share.value);
+          } else {
+            lteq_share.promise.then(function () {
+              result.push(lteq_share.value);
+            });
+          }
         }
         share.value = share_val;
         o.value = o_val;
@@ -880,22 +1093,25 @@
       }
 
       // promise to execute ready_add when both are ready
-      share.pick_promise(o).then( function () {
+      var promise = share.pick_promise(o).then( function () {
         if (typeof (share.value) === 'number') {
-          var result = share.legacy.slteq(o, op_id);
-          result.promise.then(function () {
-            mult_deferred.resolve(result.value);
+          lteq_share = share.legacy.slteq(o, op_id);
+          if (lteq_share.ready) {
+            return lteq_share.value;
+          }
+          result = lteq_share.promise.then(function () {
+            return lteq_share.value;
           });
+          return result;
         } else {
-          mult_deferred.resolve(ready_lteq());
+          return ready_lteq();
         }
       }, share.error);
       return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
     share.sgt = function (o, op_id) {
-      var mult_deferred = new Deferred();
-      var finalpromise = mult_deferred.promise;
+      var result, gt_share;
 
       var ready_gt = function () {
         var result = [];
@@ -904,7 +1120,14 @@
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
           o.value = o_val[i];
-          result.push(share.legacy.sgt(o, op_id).value);
+          gt_share = share.legacy.sgt(o, op_id);
+          if (gt_share.ready) {
+            result.push(gt_share.value);
+          } else {
+            gt_share.promise.then(function () {
+              result.push(gt_share.value);
+            });
+          }
         }
         share.value = share_val;
         o.value = o_val;
@@ -920,31 +1143,41 @@
       }
 
       // promise to execute ready_add when both are ready
-      share.pick_promise(o).then( function () {
+      var promise = share.pick_promise(o).then( function () {
         if (typeof (share.value) === 'number') {
-          var result = share.legacy.sgt(o, op_id);
-          result.promise.then(function () {
-            mult_deferred.resolve(result.value);
+          gt_share = share.legacy.sgt(o, op_id);
+          if (gt_share.ready) {
+            return gt_share.value;
+          }
+          result = gt_share.promise.then(function () {
+            return gt_share.value;
           });
+          return result;
         } else {
-          mult_deferred.resolve(ready_gt());
+          return ready_gt();
         }
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
     share.sgteq = function (o, op_id) {
-      var mult_deferred = new Deferred();
-      var finalpromise = mult_deferred.promise;
+      var result, gteq_share;
 
       var ready_gteq = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         var o_val = o.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
           o.value = o_val[i];
-          result.push(share.legacy.sgteq(o, op_id).value);
+          gteq_share = share.legacy.sgteq(o, op_id);
+          if (gteq_share.ready) {
+            result.push(gteq_share.value);
+          } else {
+            gteq_share.promise.then(function () {
+              result.push(gteq_share.value);
+            });
+          }
         }
         share.value = share_val;
         o.value = o_val;
@@ -960,31 +1193,41 @@
       }
 
       // promise to execute ready_add when both are ready
-      share.pick_promise(o).then( function () {
+      var promise = share.pick_promise(o).then( function () {
         if (typeof (share.value) === 'number') {
-          var result = share.legacy.sgteq(o, op_id);
-          result.promise.then(function () {
-            mult_deferred.resolve(result.value);
+          gteq_share = share.legacy.sgteq(o, op_id);
+          if (gteq_share.ready) {
+            return gteq_share.value;
+          }
+          result = gteq_share.promise.then(function () {
+              return gteq_share.value;
           });
+          return result;
         } else {
-          mult_deferred.resolve(ready_gteq());
+          return ready_gteq();
         }
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
     share.seq = function (o, op_id) {
-      var mult_deferred = new Deferred();
-      var finalpromise = mult_deferred.promise;
+      var result, eq_share;
 
       var ready_eq = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         var o_val = o.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
           o.value = o_val[i];
-          result.push(share.legacy.seq(o, op_id).value);
+          eq_share = share.legacy.seq(o, op_id);
+          if (eq_share.ready) {
+            result.push(eq_share.value);
+          } else {
+            eq_share.promise.then(function () {
+              result.push(eq_share.value);
+            });
+          }
         }
         share.value = share_val;
         o.value = o_val;
@@ -1000,31 +1243,41 @@
       }
 
       // promise to execute ready_add when both are ready
-      share.pick_promise(o).then( function () {
+      var promise = share.pick_promise(o).then( function () {
         if (typeof (share.value) === 'number') {
-          var result = share.legacy.seq(o, op_id);
-          result.promise.then(function () {
-            mult_deferred.resolve(result.value);
+          eq_share = share.legacy.seq(o, op_id);
+          if (eq_share.ready) {
+            return eq_share.value;
+          }
+          result = eq_share.promise.then(function () {
+            return eq_share.value;
           });
+          return result;
         } else {
-          mult_deferred.resolve(ready_eq());
+          return ready_eq();
         }
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
     share.sneq = function (o, op_id) {
-      var mult_deferred = new Deferred();
-      var finalpromise = mult_deferred.promise;
+      var result, neq_share;
 
       var ready_neq = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         var o_val = o.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
           o.value = o_val[i];
-          result.push(share.legacy.sneq(o, op_id).value);
+          neq_share = share.legacy.sneq(o, op_id);
+          if (neq_share.ready) {
+            result.push(neq_share.value);
+          } else {
+            neq_share.promise.then(function () {
+              result.push(neq_share.value);
+            });
+          }
         }
         share.value = share_val;
         o.value = o_val;
@@ -1040,34 +1293,47 @@
       }
 
       // promise to execute ready_add when both are ready
-      share.pick_promise(o).then( function () {
+      var promise = share.pick_promise(o).then( function () {
         if (typeof (share.value) === 'number') {
-          var result = share.legacy.sneq(o, op_id);
-          result.promise.then(function () {
-            mult_deferred.resolve(result.value);
+          neq_share = share.legacy.sneq(o, op_id);
+          if (neq_share.ready) {
+            return neq_share.value;
+          }
+          result = neq_share.promise.then(function () {
+            return neq_share.value;
           });
+          return result;
         } else {
-          mult_deferred.resolve(ready_neq());
+          return ready_neq();
         }
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
     share.lt_halfprime = function (op_id) {
+      var result, halfprime_share;
+
       var ready_lt_halfprime = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          result.push(share.legacy.lt_halfprime(op_id).value);
+          halfprime_share = share.legacy.lt_halfprime(op_id);
+          if (halfprime_share.ready) {
+            result.push(halfprime_share.value);
+          } else {
+            halfprime_share.promise.then(function () {
+              result.push(halfprime_share.value);
+            });
+          }
         }
         share.value = share_val;
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
-          return share.legacy.lt_halfprime(op_id).value;
+          return share.legacy.lt_halfprime(op_id);
         } else {
           return share.jiff.secret_share(share.jiff, true, null, ready_lt_halfprime(), share.holders, share.threshold, share.Zp);
         }
@@ -1075,7 +1341,14 @@
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.lt_halfprime(op_id).value;
+          halfprime_share = share.legacy.lt_halfprime(op_id);
+          if (halfprime_share.ready) {
+            return halfprime_share.value;
+          }
+          result = halfprime_share.promise.then(function () {
+            return halfprime_share.value;
+          });
+          return result;
         } else {
           return ready_lt_halfprime();
         }
@@ -1084,20 +1357,28 @@
     };
 
     share.not = function () {
+      var result, not_share;
       var ready_not = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          result.push(share.legacy.not().value);
+          not_share = share.legacy.not();
+          if (not_share.ready) {
+            result.push(not_share.value);
+          } else {
+            not_share.promise.then(function () {
+              result.push(not_share.value);
+            });
+          }
         }
         share.value = share_val;
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
-          return share.legacy.not().value;
+          return share.legacy.not();
         } else {
           return share.jiff.secret_share(share.jiff, true, null, ready_not(), share.holders, share.threshold, share.Zp);
         }
@@ -1105,7 +1386,14 @@
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.not().value;
+          not_share = share.legacy.not();
+          if (not_share.ready) {
+            return not_share.value;
+          }
+          result = not_share.promise.then(function () {
+            return not_share.value;
+          });
+          return result;
         } else {
           return ready_not();
         }
@@ -1114,18 +1402,26 @@
     };
 
     share.if_else = function (trueVal, falseVal, op_id) {
+      var result, ifelseshare;
       var ready_if_else = function () {
-        var result = [];
+        result = [];
         var share_val = share.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          result.push(share.legacy.if_else(trueVal, falseVal, op_id).value);
+          ifelseshare = share.legacy.if_else(trueVal, falseVal, op_id);
+          if (ifelseshare.ready) {
+            result.push(ifelseshare.value);
+          } else {
+            ifelseshare.promise.then(function () {
+              result.push(ifelseshare.value);
+            });
+          }
         }
         share.value = share_val;
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
           return share.legacy.if_else(trueVal, falseVal, op_id).value;
         } else {
@@ -1135,7 +1431,14 @@
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          return share.legacy.if_else(trueVal, falseVal, op_id).value;
+          ifelseshare = share.legacy.if_else(trueVal, falseVal, op_id);
+          if (ifelseshare.ready) {
+            return ifelseshare.value;
+          }
+          result = ifelseshare.promise.then(function () {
+            return ifelseshare.value;
+          });
+          return result;
         } else {
           return ready_if_else();
         }
@@ -1239,7 +1542,6 @@
 
         // Party is a receiver
         if (parties.indexOf(jiff.id) > -1) {
-          console.log('receiving');
           var shares = []; // this will store received shares
           var numberofshares = 0;
           var final_deferred = new Deferred(); // will be resolved when the final value is reconstructed
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index 8807d0b5d..d562d0867 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -2030,7 +2030,6 @@
         } else {
           // Resolve the deferred when ready.
           final_result.promise.then(function () {
-            console.log(final_result.value);
             final_deferred.resolve(final_result.value);
           });
         }
@@ -2684,7 +2683,6 @@
           one_bit(i + 1);
         });
       })(0);
-      console.log('sdiv', final_promise);
       return result;
     };
 

From 2fcad51a33012504510421434b7e219e9cae323a Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Mon, 1 Jul 2019 13:11:19 -0400
Subject: [PATCH 05/24] arithmetic operations

---
 demos/{multipleshares => asyncshare}/README.md   | 0
 demos/{multipleshares => asyncshare}/client.html | 4 ++--
 demos/{multipleshares => asyncshare}/client.js   | 0
 demos/{multipleshares => asyncshare}/mpc.js      | 0
 demos/{multipleshares => asyncshare}/party.js    | 0
 demos/{multipleshares => asyncshare}/server.js   | 4 ++--
 demos/{multipleshares => asyncshare}/test.js     | 0
 7 files changed, 4 insertions(+), 4 deletions(-)
 rename demos/{multipleshares => asyncshare}/README.md (100%)
 rename demos/{multipleshares => asyncshare}/client.html (91%)
 rename demos/{multipleshares => asyncshare}/client.js (100%)
 rename demos/{multipleshares => asyncshare}/mpc.js (100%)
 rename demos/{multipleshares => asyncshare}/party.js (100%)
 rename demos/{multipleshares => asyncshare}/server.js (73%)
 rename demos/{multipleshares => asyncshare}/test.js (100%)

diff --git a/demos/multipleshares/README.md b/demos/asyncshare/README.md
similarity index 100%
rename from demos/multipleshares/README.md
rename to demos/asyncshare/README.md
diff --git a/demos/multipleshares/client.html b/demos/asyncshare/client.html
similarity index 91%
rename from demos/multipleshares/client.html
rename to demos/asyncshare/client.html
index f1c0874ce..5111d7ff8 100644
--- a/demos/multipleshares/client.html
+++ b/demos/asyncshare/client.html
@@ -2,7 +2,7 @@
 
 <html>
   <head>
-    <title>Sum integers under Multiple Shares MPC</title>
+    <title>Sum integers under Asynchronous Share MPC</title>
     <style>
       .error {
         color: #FF0000;
@@ -26,7 +26,7 @@ <h1>Connect JIFF</h1>
     <label for="count">Party Count<label> <input id="count" pattern="[0-9]*" value="2"> &nbsp; <button id="connectButton" onclick="connect();">Connect</button>
     <br/><br/>
     <hr/>
-    <h1>Sum Numbers under Multiple Shares MPC</h1>
+    <h1>Sum Numbers under Asynchronous Shares MPC</h1>
     <label for="number">Input Number (between 0 and 100)</label> <input id="number" pattern="[0-9]+"> &nbsp; <button onclick="submit();" disabled="disabled" id="button">Sum</button><br/>
     <div id="output"></div>
   </body>
diff --git a/demos/multipleshares/client.js b/demos/asyncshare/client.js
similarity index 100%
rename from demos/multipleshares/client.js
rename to demos/asyncshare/client.js
diff --git a/demos/multipleshares/mpc.js b/demos/asyncshare/mpc.js
similarity index 100%
rename from demos/multipleshares/mpc.js
rename to demos/asyncshare/mpc.js
diff --git a/demos/multipleshares/party.js b/demos/asyncshare/party.js
similarity index 100%
rename from demos/multipleshares/party.js
rename to demos/asyncshare/party.js
diff --git a/demos/multipleshares/server.js b/demos/asyncshare/server.js
similarity index 73%
rename from demos/multipleshares/server.js
rename to demos/asyncshare/server.js
index d0a192762..56abb8067 100644
--- a/demos/multipleshares/server.js
+++ b/demos/asyncshare/server.js
@@ -14,6 +14,6 @@ http.listen(8080, function () {
   console.log('listening on *:8080');
 });
 
-console.log('Direct your browser to *:8080/demos/multipleshares/client.html.');
-console.log('To run a node.js based party: node demos/multipleshares/party <input>');
+console.log('Direct your browser to *:8080/demos/asyncshare/client.html.');
+console.log('To run a node.js based party: node demos/asyncshare/party <input>');
 console.log();
diff --git a/demos/multipleshares/test.js b/demos/asyncshare/test.js
similarity index 100%
rename from demos/multipleshares/test.js
rename to demos/asyncshare/test.js

From 737cc069f4174e2a8de84da5ee42dc1b2463f926 Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Mon, 15 Jul 2019 10:55:41 -0400
Subject: [PATCH 06/24] smult changes

---
 lib/ext/jiff-client-asynchronousshare.js      |   2 +-
 tests/suite/config/asyncShare/arithmetic.json |  58 ++++++
 tests/suite/config/asyncShare/comparison.json |  42 ++++
 tests/suite/config/asyncShare/computations.js |  60 ++++++
 .../asyncShare/constant arithmetic.json       |  44 ++++
 .../asyncShare/constant comparison.json       |  42 ++++
 tests/suite/config/asyncShare/generation.js   | 190 ++++++++++++++++++
 tests/suite/config/asyncShare/share.json      |  58 ++++++
 8 files changed, 495 insertions(+), 1 deletion(-)
 create mode 100644 tests/suite/config/asyncShare/arithmetic.json
 create mode 100644 tests/suite/config/asyncShare/comparison.json
 create mode 100644 tests/suite/config/asyncShare/computations.js
 create mode 100644 tests/suite/config/asyncShare/constant arithmetic.json
 create mode 100644 tests/suite/config/asyncShare/constant comparison.json
 create mode 100644 tests/suite/config/asyncShare/generation.js
 create mode 100644 tests/suite/config/asyncShare/share.json

diff --git a/lib/ext/jiff-client-asynchronousshare.js b/lib/ext/jiff-client-asynchronousshare.js
index 06167ff30..baec925e0 100644
--- a/lib/ext/jiff-client-asynchronousshare.js
+++ b/lib/ext/jiff-client-asynchronousshare.js
@@ -8,7 +8,7 @@
    * @type {string}
    * @memberOf jiff_asynchronousshare
    */
-  exports.name = 'asynchronousshare';
+  exports.name = 'asyncShare';
 
   function Deferred() {
     // Polyfill for jQuery Deferred
diff --git a/tests/suite/config/asyncShare/arithmetic.json b/tests/suite/config/asyncShare/arithmetic.json
new file mode 100644
index 000000000..01d76ccba
--- /dev/null
+++ b/tests/suite/config/asyncShare/arithmetic.json
@@ -0,0 +1,58 @@
+{
+  "tests": [ "+", "-", "*", "*bgw", "|", "^", "!", "abs", "/", "%" ],
+  "suiteConf": {
+    "port": 3001,
+    "extensions": [ "asyncShare" ],
+    "generation": {
+      "file": "config/asyncShare/generation.js",
+      "function": "generateArithmeticInputs"
+    },
+    "computation": {
+      "file": "config/asyncShare/computations.js",
+      "function": "compute"
+    }
+  },
+
+  "testConf": {
+    "default": {
+      "count": 100,
+      "parallel": 25,
+      "options": {
+        "Zp": 15485867,
+        "party_count": 3
+      }
+    },
+    "*bgw": {
+      "count": 100,
+      "parallel": 25,
+      "options": {
+        "Zp": 15485867,
+        "party_count": 4
+      }
+    },
+    "abs": {
+      "count": 10,
+      "parallel": 3,
+      "options": {
+        "Zp": 127,
+        "party_count": 3
+      }
+    },
+    "/": {
+      "count": 8,
+      "parallel": 3,
+      "options": {
+        "Zp": 127,
+        "party_count": 3
+      }
+    },
+    "%": {
+      "count": 8,
+      "parallel": 3,
+      "options": {
+        "Zp": 127,
+        "party_count": 3
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/suite/config/asyncShare/comparison.json b/tests/suite/config/asyncShare/comparison.json
new file mode 100644
index 000000000..42d034204
--- /dev/null
+++ b/tests/suite/config/asyncShare/comparison.json
@@ -0,0 +1,42 @@
+{
+  "tests": [ "<", "<=", ">", ">=", "==", "!=" ],
+  "suiteConf": {
+    "port": 3001,
+    "extensions": ["asyncShare"],
+    "generation": {
+      "file": "config/asyncShare/generation.js",
+      "function": "generateComparisonInputs"
+    },
+    "computation": {
+      "file": "config/asyncShare/computations.js",
+      "function": "compute"
+    }
+  },
+
+  "testConf": {
+    "default": {
+      "count": 15,
+      "parallel": 5,
+      "options": {
+        "Zp": 2039,
+        "party_count": 3
+      }
+    },
+    "==": {
+      "count": 15,
+      "parallel": 5,
+      "options": {
+        "Zp": 2039,
+        "party_count": 3
+      }
+    },
+    "!=": {
+      "count": 15,
+      "parallel": 5,
+      "options": {
+        "Zp": 2039,
+        "party_count": 3
+      }
+    }
+  }
+}
diff --git a/tests/suite/config/asyncShare/computations.js b/tests/suite/config/asyncShare/computations.js
new file mode 100644
index 000000000..0b614af4a
--- /dev/null
+++ b/tests/suite/config/asyncShare/computations.js
@@ -0,0 +1,60 @@
+// Override with different interpreters
+var baseComputations = require('../../computations.js');
+
+// How to interpret non-MPC operations
+baseComputations.openInterpreter['+'] = function (operand1, operand2) {
+  return operand1 + operand2;
+};
+baseComputations.openInterpreter['-'] = function (operand1, operand2) {
+  return operand1 - operand2;
+};
+baseComputations.openInterpreter['*'] = function (operand1, operand2) {
+  return operand1 * operand2;
+};
+baseComputations.openInterpreter['*bgw'] = function (operand1, operand2) {
+  return operand1 * operand2;
+};
+baseComputations.openInterpreter['^'] = function (operand1, operand2) {
+  return operand1 ^ operand2;
+};
+baseComputations.openInterpreter['|'] = function (operand1, operand2) {
+  return operand1 | operand2;
+};
+baseComputations.openInterpreter['/'] = function (operand1, operand2) {
+  return Math.floor(operand1 / operand2);
+};
+baseComputations.openInterpreter['%'] = function (operand1, operand2) {
+  return operand1 % operand2;
+};
+baseComputations.openInterpreter['<'] = function (operand1, operand2) {
+  return Number(operand1 < operand2);
+};
+baseComputations.openInterpreter['<='] = function (operand1, operand2) {
+  return Number(operand1 <= operand2);
+};
+baseComputations.openInterpreter['>'] = function (operand1, operand2) {
+  return Number(operand1 > operand2);
+};
+baseComputations.openInterpreter['>='] = function (operand1, operand2) {
+  return Number(operand1 >= operand2);
+};
+baseComputations.openInterpreter['=='] = function (operand1, operand2) {
+  return Number(operand1 === operand2);
+};
+baseComputations.openInterpreter['!='] = function (operand1, operand2) {
+  return Number(operand1 !== operand2);
+};
+baseComputations.openInterpreter['!'] = function (operand1, _) {
+  return (operand1 + 1) % 2;
+};
+baseComputations.openInterpreter['abs'] = function (operand1, _) {
+  return Math.abs(operand1);
+};
+
+// Add new functionality to the MPC interpreter
+baseComputations.mpcInterpreter['abs'] = function (operand1, _) {
+  return operand1.abs();
+};
+
+// Default Computation Scheme
+module.exports = baseComputations;
\ No newline at end of file
diff --git a/tests/suite/config/asyncShare/constant arithmetic.json b/tests/suite/config/asyncShare/constant arithmetic.json
new file mode 100644
index 000000000..f35d2a24a
--- /dev/null
+++ b/tests/suite/config/asyncShare/constant arithmetic.json	
@@ -0,0 +1,44 @@
+{
+  "tests": [ "+", "-", "*", "|", "^", "cdivfac", "/Zp127", "/Zp2039" ],
+  "suiteConf": {
+    "port": 3001,
+    "extensions": ["asyncShare"],
+    "generation": {
+      "file": "config/asyncShare/generation.js",
+      "function": "generateConstantArithmeticInputs"
+    },
+    "computation": {
+      "file": "config/asyncShare/computations.js",
+      "function": "compute"
+    }
+  },
+
+  "testConf": {
+    "default": {
+      "count": 100,
+      "parallel": 50,
+      "options": {
+        "Zp": 15485867,
+        "party_count": 3
+      }
+    },
+    "/Zp127": {
+      "alias": "/",
+      "count": 8,
+      "parallel": 3,
+      "options": {
+        "Zp": 127,
+        "party_count": 3
+      }
+    },
+    "/Zp2039": {
+      "alias": "/",
+      "count": 5,
+      "parallel": 3,
+      "options": {
+        "Zp": 2039,
+        "party_count": 3
+      }
+    }
+  }
+}
diff --git a/tests/suite/config/asyncShare/constant comparison.json b/tests/suite/config/asyncShare/constant comparison.json
new file mode 100644
index 000000000..c98caf4ad
--- /dev/null
+++ b/tests/suite/config/asyncShare/constant comparison.json	
@@ -0,0 +1,42 @@
+{
+  "tests": [ "<", "<=", ">", ">=", "==", "!=" ],
+  "suiteConf": {
+    "port": 3001,
+    "extensions": ["asyncShare"],
+    "generation": {
+      "file": "config/asyncShare/generation.js",
+      "function": "generateConstantComparisonInputs"
+    },
+    "computation": {
+      "file": "config/asyncShare/computations.js",
+      "function": "compute"
+    }
+  },
+
+  "testConf": {
+    "default": {
+      "count": 15,
+      "parallel": 5,
+      "options": {
+        "Zp": 2039,
+        "party_count": 3
+      }
+    },
+    "==": {
+      "count": 15,
+      "parallel": 5,
+      "options": {
+        "Zp": 2039,
+        "party_count": 3
+      }
+    },
+    "!=": {
+      "count": 15,
+      "parallel": 5,
+      "options": {
+        "Zp": 2039,
+        "party_count": 3
+      }
+    }
+  }
+}
diff --git a/tests/suite/config/asyncShare/generation.js b/tests/suite/config/asyncShare/generation.js
new file mode 100644
index 000000000..a696727d6
--- /dev/null
+++ b/tests/suite/config/asyncShare/generation.js
@@ -0,0 +1,190 @@
+exports.generateUniform = function (test, options, max) {
+  return Math.floor(Math.random() * max);
+};
+exports.generateNonZeroUniform = function (test, options, max) {
+  return Math.floor(Math.random() * (max - 1)) + 1;
+};
+exports.generateBit = function (/*test, options*/) {
+  return Math.random() < 0.5 ? 0 : 1;
+};
+exports.generateMultiple = function (test, options, max, factor) {
+  var coef = exports.generateUniform(test, options, Math.floor(max / factor));
+  return coef * factor;
+};
+exports.generateDividend = function (test, options, max, divisor) {
+  return exports.generateUniform(test, options, max);
+};
+
+// Generation API referred to from configuration JSON files
+
+// Sharing/Opening test cases with no operations
+exports.generateShareInputs = function (test, count, options) {
+  var all_parties = [];
+  for (var k = 1; k <= options.party_count; k++) {
+    all_parties.push(k);
+  }
+
+  var inputs = [];
+  // Generate test cases one at a time
+  // A test case consists of
+  // 1) input numbers
+  // 2) sharing threshold
+  // 3) array of senders
+  // 4) array of receivers
+  var max = options.max || options.Zp;
+  for (var t = 0; t < count; t++) {
+    var oneTest = { numbers: {} };
+    // Generate numbers
+    for (var p = 1; p <= options.party_count; p++) {
+      oneTest['numbers'][p] = exports.generateUniform(test, options, max);
+    }
+    // 1 <= Threshold <= party_count
+    oneTest['threshold'] = Math.floor(Math.random() * options.party_count) + 1;
+
+    // Generate senders/receivers
+    var sn = Math.ceil(Math.random() * options.party_count); // At least one sender, at most all.
+    var rn = oneTest['threshold'] + Math.floor(Math.random() * (options.party_count - oneTest['threshold'] + 1)); // At least as many receivers as threshold.
+
+    // Generate actual receivers and senders arrays
+    var senders = all_parties.slice();
+    var receivers = all_parties.slice();
+
+    // remove random parties until proper counts are reached.
+    while (senders.length > sn) {
+      senders.splice(Math.floor(Math.random() * senders.length), 1);
+    }
+    while (receivers.length > rn) {
+      receivers.splice(Math.floor(Math.random() * receivers.length), 1);
+    }
+    oneTest['senders'] = senders;
+    oneTest['receivers'] = receivers;
+
+    inputs.push(oneTest);
+  }
+  return inputs;
+};
+
+// Arithmetic inputs: one for each party except for / and % where only two inputs are needed.
+// | and ^ requires bits, while thr denominator for / and % must be non-zero.
+exports.generateArithmeticInputs = function (test, count, options) {
+  var party_count = options.party_count;
+  var max = options.max || options.Zp;
+
+  var inputs = [];
+  var t, p, oneInput;
+  if (test.startsWith('/') || test === '%') {
+    // division and mod: only two inputs, the second is non-zero.
+    for (t = 0; t < count; t++) {
+      oneInput = {};
+      oneInput[2] = exports.generateNonZeroUniform(test, options, max);
+      oneInput[1] = exports.generateDividend(test, options, max, oneInput[2]);
+      inputs.push(oneInput);
+    }
+  } else if (test === '|' || test === '^') {
+    // or and xor: inputs are binary
+    for (t = 0; t < count; t++) {
+      oneInput = {};
+      for (p = 1; p <= party_count; p++) {
+        oneInput[p] = exports.generateBit(test, options);
+      }
+      inputs.push(oneInput);
+    }
+  } else if (test === '!') {
+    for (t = 0; t < count; t++) {
+      oneInput = {};
+      oneInput[1] = exports.generateBit(test, options);
+      inputs.push(oneInput);
+    }
+    return inputs;
+  } else {
+    // otherwise no constraints
+    for (t = 0; t < count; t++) {
+      oneInput = {};
+      for (p = 1; p <= party_count; p++) {
+        oneInput[p] = exports.generateUniform(test, options, max);
+      }
+      inputs.push(oneInput);
+    }
+  }
+
+  return inputs;
+};
+
+// Constant Arithmetic inputs: an input for the first party, and a constant input.
+// | and ^ requires bits, while thr denominator for / and % must be non-zero.
+exports.generateConstantArithmeticInputs = function (test, count, options) {
+  var max = options.max || options.Zp;
+  var cmax = options.cmax || max;
+
+  var inputs = [];
+  var t, oneInput;
+  if (test.indexOf('/') > -1 || test.indexOf('%') > -1 || test === 'cdivfac') {
+    // division and mod: only two inputs, the second is non-zero.
+    for (t = 0; t < count; t++) {
+      oneInput = {};
+      oneInput['constant'] = exports.generateNonZeroUniform(test, options, cmax);
+      if (test === 'cdivfac') {
+        oneInput[1] = exports.generateMultiple(test, options, max, oneInput['constant']);
+      } else {
+        oneInput[1] = exports.generateDividend(test, options, max, oneInput['constant']);
+      }
+
+      inputs.push(oneInput);
+    }
+  } else if (test === '|' || test === '^') {
+    // or and xor: inputs are binary
+    for (t = 0; t < count; t++) {
+      oneInput = {};
+      oneInput[1] = exports.generateBit(test, options);
+      oneInput['constant'] = exports.generateBit(test, options);
+      inputs.push(oneInput);
+    }
+  } else {
+    // otherwise no constraints
+    for (t = 0; t < count; t++) {
+      oneInput = {};
+      oneInput[1] = exports.generateUniform(test, options, max);
+      oneInput['constant'] = exports.generateUniform(test, options, cmax);
+      inputs.push(oneInput);
+    }
+  }
+
+  return inputs;
+};
+
+// Constant Comparison inputs: two inputs for the first two parties only
+// if using random numbers and large Zp, inputs will be very unlikely to be equal
+// we must make it likely for the inputs to be equal manually for == and != checks
+exports.generateComparisonInputs = function (test, count, options) {
+  var max = options.max || options.Zp;
+
+  var inputs = [];
+  // make it likely that the numbers are equal.
+  for (var t = 0; t < count; t++) {
+    var oneInput = {};
+    oneInput[1] = exports.generateUniform(test, options, max);
+    oneInput[2] = Math.random() < 0.5 ? oneInput[1] : exports.generateUniform(test, options, max);
+    inputs.push(oneInput);
+  }
+
+  return inputs;
+};
+
+// Constant Comparison inputs: an input for the first party, and a constant input.
+// if using random numbers and large Zp, inputs will be very unlikely to be equal
+// we must make it likely for the inputs to be equal manually for == and != checks
+exports.generateConstantComparisonInputs = function (test, count, options) {
+  var max = options.max || options.Zp;
+  var cmax = options.cmax || max;
+
+  var inputs = [];
+  // make it likely that the numbers are equal.
+  for (var t = 0; t < count; t++) {
+    var oneInput = {};
+    oneInput[1] = exports.generateUniform(test, options, max);
+    oneInput['constant'] = Math.random() < 0.5 ? oneInput[1] : exports.generateUniform(test, options, cmax);
+    inputs.push(oneInput);
+  }
+
+  return inputs;
+};
diff --git a/tests/suite/config/asyncShare/share.json b/tests/suite/config/asyncShare/share.json
new file mode 100644
index 000000000..6f6e95720
--- /dev/null
+++ b/tests/suite/config/asyncShare/share.json
@@ -0,0 +1,58 @@
+{
+  "tests": [ "share2", "share3", "share4", "share5", "share10" ],
+  "suiteConf": {
+    "port": 3001,
+    "extensions": ["asyncShare"],
+    "generation": {
+      "file": "config/asyncShare/generation.js",
+      "function": "generateShareInputs"
+    },
+    "computation": {
+      "file": "./computations-share.js",
+      "function": "compute"
+    }
+  },
+
+  "testConf": {
+    "share2": {
+      "count": 100,
+      "parallel": 25,
+      "options": {
+        "Zp": 2039,
+        "party_count": 2
+      }
+    },
+    "share3": {
+      "count": 100,
+      "parallel": 25,
+      "options": {
+        "Zp": 2039,
+        "party_count": 3
+      }
+    },
+    "share4": {
+      "count": 80,
+      "parallel": 20,
+      "options": {
+        "Zp": 2039,
+        "party_count": 4
+      }
+    },
+    "share5": {
+      "count": 50,
+      "parallel": 20,
+      "options": {
+        "Zp": 2039,
+        "party_count": 5
+      }
+    },
+    "share10": {
+      "count": 40,
+      "parallel": 15,
+      "options": {
+        "Zp": 2039,
+        "party_count": 10
+      }
+    }
+  }
+}

From f636b53659ab21d18ca09612f859afaa6a9ab38d Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Tue, 16 Jul 2019 15:42:39 -0400
Subject: [PATCH 07/24] init extension

---
 tests/suite/init.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/suite/init.js b/tests/suite/init.js
index de9fb6aff..59cb8b70c 100644
--- a/tests/suite/init.js
+++ b/tests/suite/init.js
@@ -6,7 +6,8 @@ var extensions = {
   bigNumber: require('../../lib/ext/jiff-client-bignumber'),
   fixedpoint: require('../../lib/ext/jiff-client-fixedpoint'),
   negativeNumber: require('../../lib/ext/jiff-client-negativenumber'),
-  restAPI: require('../../lib/ext/jiff-client-restful')
+  restAPI: require('../../lib/ext/jiff-client-restful'),
+  asyncShare: require('../../lib/ext/jiff-client-asynchronousshare')
 };
 
 // Create the jiff instances for tests

From 5be203cd760e945be55ae8c53d76c056414b4c07 Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Tue, 16 Jul 2019 15:43:46 -0400
Subject: [PATCH 08/24] asyncShare server

---
 lib/ext/jiff-server-asyncshare.js | 110 ++++++++++++++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 lib/ext/jiff-server-asyncshare.js

diff --git a/lib/ext/jiff-server-asyncshare.js b/lib/ext/jiff-server-asyncshare.js
new file mode 100644
index 000000000..d91e15f03
--- /dev/null
+++ b/lib/ext/jiff-server-asyncshare.js
@@ -0,0 +1,110 @@
+global.crypto = require('crypto');
+var client_asyncshare = require('./jiff-client-asynchronousshare.js');
+
+exports.name = 'asyncshare';
+exports.make_jiff = function (base_instance, options) {
+  var jiff = base_instance;
+
+  initialize_hooks(jiff, options);
+
+  jiff.helpers.get_party_number = function (party_id, share_num, party_count) {
+    if (share_num == null) {
+      share_num = 0;
+    }
+    if (typeof(party_id) === 'number') {
+      return party_id + (share_num * (party_count+1));
+    }
+    if (party_id.startsWith('s')) {
+      return parseInt(party_id.substring(1), 10) * (party_count+1); // n+1 reserved for server
+    }
+    return parseInt(party_id, 10) + (share_num * (party_count+1));
+  };
+
+  jiff.triplet = function (computation_id, from_id, msg) {
+    // decrypt and verify signature
+    try {
+      msg = jiff.hooks.decryptSign(jiff, msg, jiff.secret_key_map[computation_id], jiff.key_map[computation_id][from_id]);
+      msg = JSON.parse(msg);
+    } catch (error) { // invalid signature
+      console.log('error decrypting message');
+      jiff.hooks.log(jiff, 'Error in triplet from ' + computation_id + '-' + from_id + ': ' + error);
+      return { success: false, error: 'invalid signature'};
+    }
+
+    try {
+      msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'triplet', computation_id, from_id, msg], 4);
+    } catch (err) {
+      return { success: false, error: typeof(err) === 'string' ? err : err.message };
+    }
+
+    // request/generate triplet share.
+    var triplet_msg = jiff.request_triplet_share(msg, computation_id, from_id);
+
+    //{triplet: all_triplets[triplet_id][from_id], triplet_id: triplet_id};
+    triplet_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'triplet', computation_id, from_id, triplet_msg], 4);
+    triplet_msg = JSON.stringify(triplet_msg);
+
+    // encrypt an sign message then send it.
+    var pkey = jiff.key_map[computation_id][from_id];
+    triplet_msg = jiff.hooks.encryptSign(jiff, triplet_msg, pkey, jiff.secret_key_map[computation_id]);
+    return { success: true, message: triplet_msg };
+  };
+
+  // Helpers for creating triplets/numbers and sharing them.
+  jiff.request_triplet_share = function (msg, computation_id, from_id) {
+    // parse message
+    var triplet_id = msg.triplet_id;
+    var receivers = msg.receivers;
+    var threshold = msg.threshold;
+    var Zp = msg.Zp;
+    var ratios = msg.ratios;
+
+    jiff.hooks.log(jiff, 'triplet ' + triplet_id + ' from ' + computation_id + '-' + from_id + ':: ' + JSON.stringify(msg));
+
+    if (jiff.triplets_map[computation_id] == null) {
+      jiff.triplets_map[computation_id] = {};
+    }
+
+    var all_triplets = jiff.triplets_map[computation_id];
+
+    if (all_triplets[triplet_id] == null) { // Generate Triplet.
+      var triplet = jiff.hooks.generateTriplet(jiff, computation_id, Zp);
+      var a = triplet.a;
+      var b = triplet.b;
+      var c = triplet.c;
+
+      var a_shares = jiff.hooks.computeShares(jiff, a, receivers, threshold, Zp, ratios);
+      var b_shares = jiff.hooks.computeShares(jiff, b, receivers, threshold, Zp, ratios);
+      var c_shares = jiff.hooks.computeShares(jiff, c, receivers, threshold, Zp, ratios);
+
+      var triplet_shares = {};
+      for (var i = 0; i < receivers.length; i++) {
+        var pid = receivers[i];
+        a = a_shares[pid];
+        b = b_shares[pid];
+        c = c_shares[pid];
+
+        triplet_shares[pid] = {a: a, b: b, c: c};
+      }
+
+      all_triplets[triplet_id] = triplet_shares;
+    }
+
+    return {triplet: all_triplets[triplet_id][from_id], triplet_id: triplet_id};
+  };
+
+  return jiff;
+};
+
+function initialize_hooks(jiff, options) {
+  if (options.hooks == null) {
+    options.hooks = {};
+  }
+
+  // sharing hooks
+  if (options.hooks.computeShares == null) {
+    jiff.hooks.computeShares = client_asyncshare.sharing_schemes.shamir_share;
+  } else {
+    jiff.hooks.computeShares = options.hooks.computeShares;
+  }
+}
\ No newline at end of file

From 4d3b8cc378f076a3c3dfd6084113fe1ff01a7c93 Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Tue, 16 Jul 2019 15:45:39 -0400
Subject: [PATCH 09/24] testfiles

---
 demos/asyncshare/mpc.js                       |    4 +-
 demos/asyncshare/server.js                    |    2 +
 lib/ext/jiff-client-asynchronousshare.js      | 1410 ++++++++---------
 lib/ext/temp.js                               |   54 +
 lib/jiff-client.js                            |   32 +-
 tests/suite/computations.js                   |   12 +-
 tests/suite/config/asyncShare/arithmetic.json |   18 +-
 tests/suite/config/asyncShare/comparison.json |    2 +-
 tests/suite/config/asyncShare/computations.js |  129 +-
 .../asyncShare/constant arithmetic.json       |    2 +-
 tests/suite/config/asyncShare/generation.js   |  196 +--
 tests/suite/config/bits/computations.js       |   49 +-
 tests/suite/config/bits/decomposition.json    |    1 +
 tests/suite/server.js                         |    6 +
 14 files changed, 975 insertions(+), 942 deletions(-)
 create mode 100644 lib/ext/temp.js

diff --git a/demos/asyncshare/mpc.js b/demos/asyncshare/mpc.js
index 3d894363b..f9a665a74 100644
--- a/demos/asyncshare/mpc.js
+++ b/demos/asyncshare/mpc.js
@@ -32,13 +32,11 @@
     // The MPC implementation should go *HERE*
     var shares = jiff_instance.share(input);
     var sum = shares[1];
-
     for (var i = 2; i <= jiff_instance.party_count; i++) {
       sum = sum.smult(shares[i]);
     }
 
     // Return a promise to the final output(s)
-    var result = jiff_instance.open(sum);
-    return result;
+    return jiff_instance.open(sum);
   };
 }((typeof exports === 'undefined' ? this.mpc = {} : exports), typeof exports !== 'undefined'));
diff --git a/demos/asyncshare/server.js b/demos/asyncshare/server.js
index 56abb8067..5a05428b8 100644
--- a/demos/asyncshare/server.js
+++ b/demos/asyncshare/server.js
@@ -2,6 +2,8 @@ var express = require('express');
 var app = express();
 var http = require('http').Server(app);
 var base_instance = require('../../lib/jiff-server').make_jiff(http, { logs:true });
+var jiffAsyncShareServer = require('../../lib/ext/jiff-server-asyncshare');
+base_instance.apply_extension(jiffAsyncShareServer);
 
 //Serve static files
 //Configure App
diff --git a/lib/ext/jiff-client-asynchronousshare.js b/lib/ext/jiff-client-asynchronousshare.js
index baec925e0..ee3bafe1a 100644
--- a/lib/ext/jiff-client-asynchronousshare.js
+++ b/lib/ext/jiff-client-asynchronousshare.js
@@ -8,7 +8,7 @@
    * @type {string}
    * @memberOf jiff_asynchronousshare
    */
-  exports.name = 'asyncShare';
+  exports.name = 'asyncshare';
 
   function Deferred() {
     // Polyfill for jQuery Deferred
@@ -34,6 +34,92 @@
     Object.freeze(this);
   }
 
+  // export functions
+  function jiff_compute_shares(jiff, secret, parties_list, threshold, Zp, parties_ratios) {
+    var shares = {}; // Keeps the shares
+    var i;
+    // Each player's random polynomial f must have
+    // degree threshold - 1, so that threshold many points are needed
+    // to interpolate/reconstruct.
+    var t = threshold - 1;
+    var polynomial = Array(t + 1); // stores the coefficients
+
+    // Each players's random polynomial f must be constructed
+    // such that f(0) = secret
+    polynomial[0] = secret;
+
+    // Compute the random polynomial f's coefficients
+    for (i = 1; i <= t; i++) {
+      polynomial[i] = jiff.helpers.random(Zp);
+    }
+    if (parties_ratios == null) {
+      // Compute each players share such that share[i] = f(i)
+      for (i = 0; i < parties_list.length; i++) {
+        var p_id = parties_list[i];
+        shares[p_id] = polynomial[0];
+        var power = jiff.helpers.get_party_number(p_id, 0, parties_list.length);
+
+        for (var j = 1; j < polynomial.length; j++) {
+          var tmp = jiff.helpers.mod((polynomial[j] * power), Zp);
+          shares[p_id] = jiff.helpers.mod((shares[p_id] + tmp), Zp);
+          power = jiff.helpers.mod(power * jiff.helpers.get_party_number(p_id, 0, parties_list.length), Zp);
+        }
+      }
+      return shares;
+    }
+
+    // Compute each players share such that share[i] = f(i)
+    for (i = 0; i < parties_list.length; i++) {
+      var p_id = parties_list[i];
+      var p_ratio = p_id in parties_ratios ? parties_ratios[p_id] : 1;
+      shares[p_id] = [];
+      for (var share_num = 0; share_num < p_ratio; share_num++) {
+        shares[p_id][share_num] = polynomial[0];
+        var power = jiff.helpers.get_party_number(p_id, share_num, parties_list.length);
+
+        for (var j = 1; j < polynomial.length; j++) {
+          var tmp = jiff.helpers.mod((polynomial[j] * power), Zp);
+          shares[p_id][share_num] = jiff.helpers.mod((shares[p_id][share_num] + tmp), Zp);
+          power = jiff.helpers.mod(power * jiff.helpers.get_party_number(p_id, share_num, parties_list.length), Zp);
+        }
+      }
+    }
+    return shares;
+  }
+
+  function jiff_lagrange(jiff, shares) {
+    var lagrange_coeff = []; // will contain shares.length many elements.
+    // Compute the Lagrange coefficients at 0.
+    for (var i = 0; i < shares.length; i++) {
+      for (var share_num = 0; share_num < shares[i].value.length; share_num++) {
+        var pi = jiff.helpers.get_party_number(shares[i].sender_id, share_num, jiff.party_count);
+        lagrange_coeff[pi] = 1;
+
+        for (var j = 0; j < shares.length; j++) {
+          for (var n = 0; n < shares[j].value.length; n++) {
+            var pj = jiff.helpers.get_party_number(shares[j].sender_id, n, jiff.party_count);
+            if (pj !== pi) {
+              var inv = jiff.helpers.extended_gcd(pi - pj, shares[i].Zp)[0];
+              lagrange_coeff[pi] = jiff.helpers.mod(lagrange_coeff[pi] * (0 - pj), shares[i].Zp) * inv;
+              lagrange_coeff[pi] = jiff.helpers.mod(lagrange_coeff[pi], shares[i].Zp);
+            }
+          }
+        }
+      }
+    }
+
+    // Reconstruct the secret via Lagrange interpolation
+    var recons_secret = 0;
+    for (var p = 0; p < shares.length; p++) {
+      for (share_num = 0; share_num < shares[p].value.length; share_num++) {
+        var party = jiff.helpers.get_party_number(shares[p].sender_id, share_num, jiff.party_count);
+        var tmp = jiff.helpers.mod((shares[p].value[share_num] * lagrange_coeff[party]), shares[p].Zp);
+        recons_secret = jiff.helpers.mod((recons_secret + tmp), shares[p].Zp);
+      }
+    }
+    return recons_secret;
+  }
+
   function createMultipleSharesSecretShare(jiff, share, share_helpers) {
     // Keep a copy of the previous implementation of changed primitives
     share.legacy = {};
@@ -53,12 +139,100 @@
       return x > y ? x : y;
     }
 
+    share.open = function (parties, op_ids) {
+      return share.jiff.open(share, parties, op_ids);
+    };
+
+    share.add = function (o) {
+      if (share.isConstant(o)) {
+        return share.cadd(o);
+      }
+      return share.sadd(o);
+    };
+
+    share.sub = function (o) {
+      if (share.isConstant(o)) {
+        return share.csub(o);
+      }
+      return share.ssub(o);
+    };
+
+    share.mult = function (o, op_id) {
+      if (share.isConstant(o)) {
+        return share.cmult(o);
+      }
+      return share.smult(o, op_id);
+    };
+
+    share.xor_bit = function (o) {
+      if (share.isConstant(o)) {
+        return share.cxor_bit(o);
+      }
+      return share.sxor_bit(o);
+    };
+
+    share.or_bit = function (o, op_id) {
+      if (share.isConstant(o)) {
+        return share.cor_bit(o);
+      }
+      return share.sor_bit(o, op_id);
+    };
+
+    share.gteq = function (o) {
+      if (share.isConstant(o)) {
+        return share.cgteq(o);
+      }
+      return share.sgteq(o);
+    };
+
+    share.gt = function (o) {
+      if (share.isConstant(o)) {
+        return share.cgt(o);
+      }
+      return share.sgt(o);
+    };
+
+    share.lteq = function (o) {
+      if (share.isConstant(o)) {
+        return share.clteq(o);
+      }
+      return share.slteq(o);
+    };
+
+    share.lt = function (o) {
+      if (share.isConstant(o)) {
+        return share.clt(o);
+      }
+      return share.slt(o);
+    };
+
+    share.eq = function (o) {
+      if (share.isConstant(o)) {
+        return share.ceq(o);
+      }
+      return share.seq(o);
+    };
+
+    share.neq = function (o) {
+      if (share.isConstant(o)) {
+        return share.cneq(o);
+      }
+      return share.sneq(o);
+    };
+
+    share.div = function (o) {
+      if (share.isConstant(o)) {
+        return share.cdiv(o);
+      }
+      return share.sdiv(o);
+    };
+
     share.cadd = function (o) {
-      var result, addshare;
+      if (!(share.isConstant(o))) {
+        throw new Error('parameter should be a number (+)');
+      }
+
       var ready_add = function () {
-        if (!(share.isConstant(o))) {
-          throw new Error('parameter should be a number (+)');
-        }
         var result = [];
         for (var i = 0; i < share.value.length; i++) {
             result.push(jiff.helpers.mod(share_helpers['+'](share.value[i], o), share.Zp));
@@ -67,45 +241,35 @@
       };
 
       if (share.ready) {
-        if (typeof (share.value) === 'number') {
+        if (typeof(share.value) == 'number') {
           return share.legacy.cadd(o);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_add(), share.holders, share.threshold, share.Zp);
         }
+        return share.jiff.secret_share(share.jiff, true, null, ready_add(), share.holders, share.threshold, share.Zp, null, share.ratios);
       }
 
       var promise = share.promise.then(function () {
-        if (typeof (share.value) === 'number') {
-          addshare = share.legacy.cadd(o);
-          if (addshare.ready) {
-            return addshare.value;
-          }
-          result = addshare.promise.then(function () {
-            return addshare.value;
-          });
-          return result;
-        } else {
-          return ready_add();
+        if (typeof(share.value) == 'number') {
+          return (share.legacy.cadd(o)).promise;
         }
+        return ready_add(o);
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp, null, share.ratios);
     };
-    
+
     share.sadd = function (o) {
-      var result, addshare;
+      if (!(o.jiff === share.jiff)) {
+        throw new Error('shares do not belong to the same instance (+)');
+      }
+      if (!share.jiff.helpers.Zp_equals(share, o)) {
+        throw new Error('shares must belong to the same field (+)');
+      }
+      if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
+        throw new Error('shares must be held by the same parties (+)');
+      }
 
+      // add the two share when ready
       var ready_add = function () {
-        if (!(o.jiff === share.jiff)) {
-          throw new Error('shares do not belong to the same instance (+)');
-        }
-        if (!share.jiff.helpers.Zp_equals(share, o)) {
-          throw new Error('shares must belong to the same field (+)');
-        }
-        if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
-          throw new Error('shares must be held by the same parties (+)');
-        }
-
-        result = [];
+        var result = [];
         for (var i = 0; i < share.value.length; i++) {
           result.push(share.jiff.helpers.mod(share_helpers['+'](share.value[i], o.value[i]), share.Zp));
         }
@@ -113,34 +277,29 @@
       };
 
       if (share.ready && o.ready) {
-        if (typeof (share.value) === 'number') {
+        if (typeof(share.value) == 'number') {
           return share.legacy.sadd(o);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_add(), share.holders, max(share.threshold, o.threshold), share.Zp);
         }
+        return share.jiff.secret_share(share.jiff, true, null, ready_add(), share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
       }
 
       var promise = share.pick_promise(o).then( function () {
-        if (typeof (share.value) === 'number') {
-          addshare = share.legacy.sadd(o);
-          if (addshare.ready) {
-            return addshare.value;
-          }
-          result = addshare.promise.then(function () {
-            return addshare.value;
-          });
-          return result;
-        } else {
-          return ready_add();
+        if (typeof(share.value) == 'number') {
+          var result = share.legacy.sadd(o);
+          return result.promise;
         }
+        return ready_add();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
     };
 
     share.csub = function (o) {
-      var result, subshare;
+      if (!(share.isConstant(o))) {
+        throw new Error('parameter should be a number (-)');
+      }
+
       var ready_sub = function () {
-        result = [];
+        var result = [];
         for (var i = 0; i < share.value.length; i++) {
           result.push(jiff.helpers.mod(share_helpers['-'](share.value[i], o), share.Zp));
         }
@@ -148,45 +307,34 @@
       };
 
       if (share.ready) {
-        if (typeof (share.value) === 'number') {
+        if (typeof(share.value) == 'number') {
           return share.legacy.csub(o);
-        } else {
-          share.jiff.secret_share(share.jiff, true, null, ready_sub(), share.holders, share.threshold, share.Zp);
         }
+        return share.jiff.secret_share(share.jiff, true, null, ready_sub(), share.holders, share.threshold, share.Zp, null, share.ratios);
       }
 
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          subshare = share.legacy.csub(o);
-          if (subshare.ready) {
-            return subshare.value;
-          }
-          result = subshare.promise.then(function () {
-            return subshare.value;
-          });
-          return result;
-        } else {
-          return ready_sub();
+      var promise = share.promise.then(function () {
+        if (typeof(share.value) == 'number') {
+          return (share.legacy.csub(o)).promise;
         }
+        return ready_sub();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp, null, share.ratios);
     };
 
     share.ssub = function (o) {
-      var result, subshare;
+      if (!(o.jiff === share.jiff)) {
+        throw new Error('shares do not belong to the same instance (-)');
+      }
+      if (!share.jiff.helpers.Zp_equals(share, o)) {
+        throw new Error('shares must belong to the same field (-)');
+      }
+      if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
+        throw new Error('shares must be held by the same parties (-)');
+      }
 
       var ready_sub = function () {
-        if (!(o.jiff === share.jiff)) {
-          throw new Error('shares do not belong to the same instance (+)');
-        }
-        if (!share.jiff.helpers.Zp_equals(share, o)) {
-          throw new Error('shares must belong to the same field (+)');
-        }
-        if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
-          throw new Error('shares must be held by the same parties (+)');
-        }
-
-        result = [];
+        var result = [];
         for (var i = 0; i < share.value.length; i++) {
           result.push(share.jiff.helpers.mod(share_helpers['-'](share.value[i], o.value[i]), share.Zp));
         }
@@ -194,39 +342,29 @@
       };
 
       if (share.ready && o.ready) {
-        if (typeof (share.value) === 'number') {
+        if (typeof(share.value) == 'number') {
           return share.legacy.ssub(o);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_sub(), share.holders, max(share.threshold, o.threshold), share.Zp);
         }
+        return share.jiff.secret_share(share.jiff, true, null, ready_sub(), share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
       }
 
       // promise to execute ready_add when both are ready
-      var promise = share.pick_promise(o).then( function () {
-        if (typeof (share.value) === 'number') {
-          subshare = share.legacy.ssub(o);
-          if (subshare.ready) {
-            return subshare.value;
-          }
-          result = subshare.promise.then(function () {
-            return subshare.value;
-          });
-          return result;
-        } else {
-          return ready_sub();
+      var promise = share.pick_promise(o).then(function () {
+        if (typeof(share.value) == 'number') {
+          return (share.legacy.ssub(o).promise);
         }
-      });
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+        return ready_sub();
+      }, share.error);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
     };
 
     share.cmult = function (o) {
-      var result, multshare;
-      var ready_mult = function () {
-        if (!(share.isConstant(o))) {
-          throw new Error('parameter should be a number (*)');
-        }
+      if (!(share.isConstant(o))) {
+        throw new Error('parameter should be a number (*)');
+      }
 
-        result = [];
+      var ready_mult = function () {
+        var result = [];
         for (var i = 0; i < share.value.length; i++) {
           result.push(jiff.helpers.mod(share_helpers['*'](share.value[i], o), share.Zp));
         }
@@ -234,129 +372,122 @@
       };
 
       if (share.ready) {
-        if (typeof (share.value) === 'number') {
+        if (typeof(share.value) == 'number') {
           return share.legacy.cmult(o);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_mult(), share.holders, share.threshold, share.Zp);
         }
+        return share.jiff.secret_share(share.jiff, true, null, ready_mult(), share.holders, share.threshold, share.Zp, null, share.ratios);
       }
 
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          multshare = share.legacy.cmult(o);
-          if (multshare.ready) {
-            return multshare.value;
-          }
-          result = multshare.promise.then(function () {
-            return multshare.value;
-          });
-          return result;
-        } else {
-          return ready_mult();
+      var promise = share.promise.then(function () {
+        if (typeof(share.value) == 'number') {
+          return (share.legacy.cmult(o).promise);
         }
+        return ready_mult();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp, null, share.ratios);
     };
 
     share.smult = function (o, op_id) {
-      var result, multshare;
-
-      var ready_mult = function () {
-        result = [];
-        var share_val = share.value;
-        var o_val = o.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          o.value = o_val[i];
-          multshare = share.legacy.smult(o, op_id);
-          if (multshare.ready) {
-            result.push(multshare.value);
-          } else {
-            multshare.promise.then(function () {
-              result.push(multshare.value);
-            });
-          }
-        }
-        share.value = share_val;
-        o.value = o_val;
-        return result;
-      };
+      if (!(o.jiff === share.jiff)) {
+        throw new Error('shares do not belong to the same instance (*)');
+      }
+      if (!share.jiff.helpers.Zp_equals(share, o)) {
+        throw new Error('shares must belong to the same field (*)');
+      }
+      if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
+        throw new Error('shares must be held by the same parties (*)');
+      }
 
-      if (share.ready && o.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.smult(o, op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_mult(), share.holders, share.threshold, share.Zp);
-        }
+      if (op_id == null) {
+        op_id = share.jiff.counters.gen_op_id('*', share.holders);
       }
 
-      // promise to execute ready_add when both are ready
-      var promise = share.pick_promise(o).then( function () {
-        if (typeof (share.value) === 'number') {
-          multshare = share.legacy.smult(o);
-          if (multshare.ready) {
-            return multshare.value;
-          }
-          result = multshare.promise.then(function () {
-            return multshare.value;
-          });
-          return result;
-        } else {
-          return ready_mult();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
-    };
+      var final_deferred = new Deferred();
+      var final_promise = final_deferred.promise;
+      var result = share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp, 'share:' + op_id, share.ratios);
+
+      // Get shares of triplets.
+      var triplet = jiff.triplet(share.holders, max(share.threshold, o.threshold), share.Zp, op_id + ':triplet', share.ratios);
+
+      var a = triplet[0];
+      var b = triplet[1];
+      var c = triplet[2];
+
+      // d = s - a. e = o - b.
+      var d = share.isadd(a.icmult(-1));
+      var e = o.isadd(b.icmult(-1));
+
+      // Open d and e.
+      // The only communication cost.
+      var e_promise = share.jiff.internal_open(e, e.holders, op_id + ':open1');
+      var d_promise = share.jiff.internal_open(d, d.holders, op_id + ':open2');
+
+      Promise.all([e_promise, d_promise]).then(function (arr) {
+        var e_open = arr[0];
+        var d_open = arr[1];
+
+        // result_share = d_open * e_open + d_open * b_share + e_open * a_share + c.
+        var t1 = share.jiff.helpers.mod(share_helpers['*'](d_open, e_open), share.Zp);
+        var t2 = b.icmult(d_open);
+        var t3 = a.icmult(e_open);
+
+        // All this happens locally.
+        var final_result = t2.icadd(t1);
+        final_result = final_result.isadd(t3);
+        final_result = final_result.isadd(c);
+
+        final_result.wThen(final_deferred.resolve);
+      });
 
+      return result;
+    };
 
     share.smult_bgw = function(o, op_id) {
-      var result, multshare;
+      if (!(o.jiff === share.jiff)) {
+        throw new Error('shares do not belong to the same instance (bgw*)');
+      }
+      if (!share.jiff.helpers.Zp_equals(share, o)) {
+        throw new Error('shares must belong to the same field (bgw*)');
+      }
+      if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
+        throw new Error('shares must be held by the same parties (bgw*)');
+      }
+      if ((share.threshold - 1) + (o.threshold - 1) > share.holders.length - 1) {
+        throw new Error('threshold too high for BGW (*)');
+      }
+      var final_deferred = new Deferred();
+      var final_promise = final_deferred.promise;
 
       var ready_mult_bgw = function () {
-        result = [];
-        var share_val = share.value;
-        var o_val = o.value;
+        var result = [];
+        var promises = [];
+
         for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          o.value = o_val[i];
-          multshare = share.legacy.smult_bgw(o, op_id);
-          if (multshare.ready) {
-            result.push(multshare.value);
-          } else {
-            multshare.promise.then(function () {
-              result.push(multshare.value);
-            });
-          }
+          var share_tmp = jiff.secret_share(share.jiff, true, null, share.value[i], share.holders, share.threshold, share.Zp);
+          var o_tmp = jiff.secret_share(o.jiff, true, null, o.value[i], o.holders, o.threshold, o.Zp);
+          var multshare = share_tmp.legacy.smult_bgw(o_tmp, op_id);
+          promises.push(multshare.promise);
+
+          multshare.promise.then((function (i, multshare) {
+            result[i] = multshare.value;
+          }).bind(null, i, multshare));
         }
-        share.value = share_val;
-        o.value = o_val;
-        return result;
+
+        Promise.all(promises).then(function () {
+          final_deferred.resolve(result);
+        }, share.error);
       };
 
       if (share.ready && o.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.smult_bgw(o, op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_mult_bgw(), share.holders, max(share.threshold, o.threshold), share.Zp);
-        }
+        ready_mult_bgw();
+        return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
       }
 
       // promise to execute ready_add when both are ready
-      var promise = share.pick_promise(o).then( function () {
-        if (typeof (share.value) === 'number') {
-          multshare = share.legacy.smult_bgw(o, op_id);
-          if (multshare.ready) {
-            return multshare.value;
-          }
-          result = multshare.promise.then(function () {
-            return multshare.value;
-          });
-          return result;
-        } else {
-          return ready_mult_bgw();
-        }
+      share.pick_promise(o).then( function () {
+        ready_mult_bgw();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
     share.cdiv = function (o, op_id) {
@@ -452,53 +583,40 @@
     };
 
     share.sdiv = function (o, l, op_id) {
-      var result, divshare;
+      var final_deferred = new Deferred();
+      var final_promise = final_deferred.promise;
 
       var ready_div = function () {
-        result = [];
-        var share_val = share.value;
-        var o_val = o.value;
+        var result = [];
+        var promises = [];
+
         for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          o.value = o_val[i];
-          divshare = share.legacy.sdiv(o, l, op_id);
-          if (divshare.ready) {
-            result.push(divshare.value);
-          } else {
-            divshare.promise.then(function () {
-              result.push(divshare.value);
-            });
-          }
+          var share_tmp = jiff.secret_share(share.jiff, true, null, share.value[i], share.holders, share.threshold, share.Zp, null, share.ratios);
+          var o_tmp = jiff.secret_share(o.jiff, true, null, o.value[i], o.holders, o.threshold, o.Zp, null, o.ratios);
+          var divshare = share_tmp.legacy.sdiv(o_tmp, l, op_id + ':' + i);
+          promises.push(divshare.promise);
+
+          divshare.promise.then((function (i, divshare) {
+            console.log('divshare', i, divshare.value);
+            result[i] = divshare.value;
+          }).bind(null, i, divshare));
         }
-        share.value = share_val;
-        o.value = o_val;
-        return result;
+
+        Promise.all(promises).then(function () {
+          final_deferred.resolve(result);
+        });
       };
 
       if (share.ready && o.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.sdiv(o, l, op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_div(), share.holders, max(share.threshold, o.threshold), share.Zp);
-        }
+        ready_div();
+        return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
       }
 
       // promise to execute ready_add when both are ready
-      var promise = share.pick_promise(o).then( function () {
-        if (typeof (share.value) === 'number') {
-          divshare = share.legacy.sdiv(o, l, op_id);
-          if (divshare.ready) {
-            return divshare.value;
-          }
-          result = divshare.promise.then(function () {
-            return divshare.value;
-          });
-          return result;
-        } else {
-          return ready_div();
-        }
+      share.pick_promise(o).then( function () {
+        ready_div();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
     share.smod = function (o, l, op_id) {
@@ -549,115 +667,21 @@
         }
       }, share.error);
       return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
-    };
-
-    share.cxor_bit = function (o) {
-      var result, xor_share;
-      var ready_xor_bit = function () {
-        result = [];
-        var share_val = share.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          xor_share = share.legacy.cxor_bit(o);
-          if (xor_share.ready) {
-            result.push(xor_share.value);
-          } else {
-            xor_share.promise.then(function () {
-              result.push(xor_share.value);
-            });
-          }
-        }
-        share.value = share_val;
-        return result;
-      };
-
-      if (share.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.cxor_bit(o);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_xor_bit(), share.holders, share.threshold, share.Zp);
-        }
-      }
-
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          xor_share = share.legacy.cxor_bit(o);
-          if (xor_share.ready) {
-            return xor_share.value;
-          }
-          result = xor_share.promise.then(function () {
-            return xor_share.value;
-          });
-          return result;
-        } else {
-          return ready_xor_bit();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };
-
-    share.sxor_bit = function (o, op_id) {
-      var result, xor_share;
-      var ready_xor_bit = function () {
-        result = [];
-        var share_val = share.value;
-        var o_val = o.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          o.value = o_val[i];
-          xor_share = share.legacy.sxor_bit(o, op_id);
-          if (xor_share.ready) {
-            result.push(xor_share.value);
-          } else {
-            xor_share.promise.then(function () {
-              result.push(xor_share.value);
-            });
-          }
-        }
-        share.value = share_val;
-        o.value = o_val;
-        return result;
-      };
-
-      if (share.ready && o.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.sxor_bit(o, op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_xor_bit(), share.holders, max(share.threshold, o.threshold), share.Zp);
-        }
-      }
-
-      // promise to execute ready_add when both are ready
-      var promise = share.pick_promise(o).then( function () {
-        if (typeof (share.value) === 'number') {
-          xor_share = share.legacy.sxor_bit(o, op_id);
-          if (xor_share.ready) {
-            return xor_share.value;
-          }
-          result = xor_share.promise.then(function () {
-            return xor_share.value;
-          });
-          return result;
-        } else {
-          return ready_xor_bit();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
-    };
-
-    share.cor_bit = function (o) {
-      var result, or_share;
-      var ready_or_bit = function () {
+    };
+
+    share.cxor_bit = function (o) {
+      var result, xor_share;
+      var ready_xor_bit = function () {
         result = [];
         var share_val = share.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          or_share = share.legacy.cor_bit(o);
-          if (or_share.ready) {
-            result.push(or_share.value);
+          xor_share = share.legacy.cxor_bit(o);
+          if (xor_share.ready) {
+            result.push(xor_share.value);
           } else {
-            or_share.promise.then(function () {
-              result.push(or_share.value);
+            xor_share.promise.then(function () {
+              result.push(xor_share.value);
             });
           }
         }
@@ -667,40 +691,38 @@
 
       if (share.ready) {
         if (typeof (share.value) === 'number') {
-          return share.legacy.cor_bit(o).value;
+          return share.legacy.cxor_bit(o);
         } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_or_bit(), share.holders, share.threshold, share.Zp);
+          return share.jiff.secret_share(share.jiff, true, null, ready_xor_bit(), share.holders, share.threshold, share.Zp);
         }
       }
 
       var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          or_share = share.legacy.cor_bit(o);
-          if (or_share.ready) {
-            return or_share.value;
+          xor_share = share.legacy.cxor_bit(o);
+          if (xor_share.ready) {
+            return xor_share.value;
           }
-          result = or_share.promise.then(function () {
-            return or_share.value;
+          result = xor_share.promise.then(function () {
+            return xor_share.value;
           });
           return result;
         } else {
-          return ready_or_bit();
+          return ready_xor_bit();
         }
       }, share.error);
       return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
     };
 
-    share.sor_bit = function (o, op_id) {
-      var result, or_share;
 
+    share.cor_bit = function (o) {
+      var result, or_share;
       var ready_or_bit = function () {
         result = [];
         var share_val = share.value;
-        var o_val = o.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
-          o.value = o_val[i];
-          or_share = share.legacy.sor_bit(o, op_id);
+          or_share = share.legacy.cor_bit(o);
           if (or_share.ready) {
             result.push(or_share.value);
           } else {
@@ -710,22 +732,20 @@
           }
         }
         share.value = share_val;
-        o.value = o_val;
         return result;
       };
 
-      if (share.ready && o.ready) {
+      if (share.ready) {
         if (typeof (share.value) === 'number') {
-          return share.legacy.sor_bit(o, op_id);
+          return share.legacy.cor_bit(o).value;
         } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_or_bit(), share.holders, max(share.threshold, o.threshold), share.Zp);
+          return share.jiff.secret_share(share.jiff, true, null, ready_or_bit(), share.holders, share.threshold, share.Zp);
         }
       }
 
-      // promise to execute ready_add when both are ready
-      var promise = share.pick_promise(o).then( function () {
+      var promise = share.promise.then( function () {
         if (typeof (share.value) === 'number') {
-          or_share = share.legacy.sor_bit(o, op_id);
+          or_share = share.legacy.cor_bit(o);
           if (or_share.ready) {
             return or_share.value;
           }
@@ -737,7 +757,7 @@
           return ready_or_bit();
         }
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
     };
 
     share.clt = function (o, op_id) {
@@ -803,7 +823,7 @@
         }
         share.value = share_val;
         return result;
-        };
+      };
 
         if (share.ready) {
           if (typeof (share.value) === 'number') {
@@ -1011,39 +1031,41 @@
     };
 
     share.slt = function (o, op_id) {
-      var result, lt_share;
+      var final_deferred = new Deferred();
+      var final_promise = final_deferred.promise;
 
       var ready_lt = function () {
-        result = [];
-        var share_val = share.value;
-        var o_val = o.value;
+        var result = [];
+        var promises = [];
+
         for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          o.value = o_val[i];
-          lt_share = share.legacy.slt(o, op_id);
-          if (lt_share.ready) {
-            result.push(lt_share.value);
-          } else {
-            lt_share.promise.then(function () {
-              result.push(lt_share.value);
-            });
-          }
+          var share_tmp = jiff.secret_share(share.jiff, true, null, share.value[i], share.holders, share.threshold, share.Zp, null, share.ratios);
+          var o_tmp = jiff.secret_share(o.jiff, true, null, o.value[i], o.holders, o.threshold, o.Zp, null, o.ratios);
+          var lt_share = share_tmp.legacy.slt(o_tmp, op_id);
+          promises.push(lt_share.promise);
+
+
+          lt_share.promise.then((function (i, lt_share) {
+            result[i] = lt_share.value;
+          }).bind(null, i, lt_share));
         }
-        share.value = share_val;
-        o.value = o_val;
-        return result;
+
+        Promise.all(promises).then(function () {
+          final_deferred.resolve(result);
+        });
       };
 
       if (share.ready && o.ready) {
         if (typeof (share.value) === 'number') {
           return share.legacy.slt(o, op_id);
         } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_lt(), share.holders, max(share.threshold, o.threshold), share.Zp);
+          ready_lt()
+          return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
         }
       }
 
       // promise to execute ready_add when both are ready
-      var promise = share.pick_promise(o).then( function () {
+      share.pick_promise(o).then( function () {
         if (typeof (share.value) === 'number') {
           lt_share = share.legacy.slt(o, op_id);
           if (lt_share.ready) {
@@ -1057,7 +1079,7 @@
           ready_lt();
         }
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
     share.slteq = function (o, op_id) {
@@ -1310,7 +1332,7 @@
       return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
-    share.lt_halfprime = function (op_id) {
+    /*share.lt_halfprime = function (op_id) {
       var result, halfprime_share;
 
       var ready_lt_halfprime = function () {
@@ -1354,9 +1376,9 @@
         }
       }, share.error);
       return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };
+    };*/
 
-    share.not = function () {
+    /*share.not = function () {
       var result, not_share;
       var ready_not = function () {
         result = [];
@@ -1399,7 +1421,7 @@
         }
       }, share.error);
       return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };
+    };*/
 
     share.if_else = function (trueVal, falseVal, op_id) {
       var result, ifelseshare;
@@ -1446,21 +1468,16 @@
       return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
     };
 
+    share.isadd = share.sadd;
+    share.issub = share.ssub;
+    share.ismult = share.smult;
+    share.icadd = share.cadd;
+    share.icsub = share.csub;
+    share.icmult = share.cmult;
+
     return share;
   }
 
-  function afterOperationMultipleShares (jiff, label, msg) {
-    if (label === 'share' || label === 'open') {
-      if (msg['share'].length >= 1) {
-        for (var i = 0; i < msg['share'].length; i++) {
-          msg['share'][i] = parseInt(msg['share'][i], 10);
-        }
-      } else {
-        msg['share'] = parseInt(msg['share'], 10);
-      }
-    }
-    return msg;
-  };
 
   function make_jiff(base_instance, options) {
     var jiff = base_instance;
@@ -1470,151 +1487,45 @@
       options = {};
     }
 
-    old_open = jiff.open;
-    jiff.open = function(share, parties, op_ids) {
-      var openresult;
-      var open_deferred = new Deferred();
-      var open_promise = open_deferred.promise;
-
-      var jiff_open = function() {
-        var i;
-
-        if (!(share.jiff === jiff)) {
-          throw 'share does not belong to given instance';
-        }
-
-        // Default values
-        if (parties == null || parties === []) {
-          parties = [];
-          for (i = 1; i <= jiff.party_count; i++) {
-            parties.push(i);
-          }
-        } else {
-          parties.sort();
-        }
-
-        // If not a receiver nor holder, do nothing
-        if (share.holders.indexOf(jiff.id) === -1 && parties.indexOf(jiff.id) === -1) {
-          return null;
-        }
-
-        // Compute operation ids (one for each party that will receive a result
-        if (op_ids == null) {
-          op_ids = {};
-        }
-
-        if (typeof (op_ids) === 'string' || typeof (op_ids) === 'number') {
-          var tmp = {};
-          for (i = 0; i < parties.length; i++) {
-            tmp[parties[i]] = op_ids;
-          }
-          op_ids = tmp;
-        } else {
-          var holders_label = share.holders.join(',');
-          for (i = 0; i < parties.length; i++) {
-            if (op_ids[parties[i]] == null) {
-              op_ids[parties[i]] = jiff.counters.gen_open_id(parties[i], holders_label);
-            }
-          }
-        }
-
-        // Party is a holder
-        if (share.holders.indexOf(jiff.id) > -1) {
-          // Call hook
-          share = jiff.execute_array_hooks('beforeOpen', [jiff, share, parties], 1);
-
-          // refresh/reshare, so that the original share remains secret, instead
-          // a new share is sent/open without changing the actual value.
-          share = share.refresh('refresh:' + op_ids[parties[0]]);
-
-          // The given share has been computed, share it to all parties
-          if (share.ready) {
-            jiff_broadcast(jiff, share, parties, op_ids);
-          } else {
-            jiff.counters.pending_opens++;
-            // Share is not ready, setup sharing as a callback to its promise
-            share.promise.then(function () {
-              jiff.counters.pending_opens--;
-              jiff_broadcast(jiff, share, parties, op_ids);
-            }, share.error);
-          }
-        }
-
-        // Party is a receiver
-        if (parties.indexOf(jiff.id) > -1) {
-          var shares = []; // this will store received shares
-          var numberofshares = 0;
-          var final_deferred = new Deferred(); // will be resolved when the final value is reconstructed
-          var final_promise = final_deferred.promise;
-          for (i = 0; i < share.holders.length; i++) {
-            var p_id = share.holders[i];
+    jiff.helpers.get_party_number = function (party_id, share_num, party_count) {
+      if (share_num == null){
+        share_num = 0;
+      }
+      if (typeof(party_id) === 'number') {
+        return party_id + (share_num * (jiff.party_count+1));
+      }
+      if (party_id.startsWith('s')) {
+        return parseInt(party_id.substring(1), 10) * (jiff.party_count+1); // n+1 reserved for server
+      }
+      return parseInt(party_id, 10) + (share_num * (jiff.party_count+1));
+    };
 
-            // Setup a deferred for receiving a share from party p_id
-            if (jiff.deferreds[op_ids[jiff.id]] == null) {
-              jiff.deferreds[op_ids[jiff.id]] = {};
-            }
-            if (jiff.deferreds[op_ids[jiff.id]][p_id] == null) {
-              jiff.deferreds[op_ids[jiff.id]][p_id] = new Deferred();
-            }
+    var old_secret_share = jiff.secret_share;
+    jiff.secret_share = function (jiff, ready, promise, value, holders, threshold, Zp, id, ratios) {
+      var share = old_secret_share(jiff, ready, promise, value, holders, threshold, Zp, id);
+      if (!(ratios == null)) {
+        share.ratios = ratios;
+      }
+      return share;
+    };
 
-            // Clean up deferred when fulfilled
-            var promise = jiff.deferreds[op_ids[jiff.id]][p_id].promise;
-
-            // destroy deferred when done
-            (function (promise, p_id) { // p_id is modified in a for loop, must do this to avoid scoping issues.
-              promise.then(function (received_share) {
-                jiff.deferreds[op_ids[jiff.id]][p_id] = null;
-                shares.push(received_share);
-                numberofshares += received_share['value'].length;
-
-                // Too few shares, nothing to do.
-                if (numberofshares < share.threshold) {
-                  return;
-                }
-
-                // Enough shares to reconstruct.
-                // If did not already reconstruct, do it.
-                if (final_deferred != null) {
-                  var recons_secret = jiff_lagrange(jiff, shares);
-                  recons_secret = jiff.execute_array_hooks('afterReconstructShare', [jiff, recons_secret], 1);
-                  final_deferred.resolve(recons_secret);
-                  final_deferred = null;
-                }
-
-                // If all shares were received, clean up.
-                if (shares.length === share.holders.length) {
-                  shares = null;
-                  jiff.deferreds[op_ids[jiff.id]] = null;
-                }
-              });
-            })(promise, p_id);
-          }
-          return final_promise;
+    function jiff_broadcast(jiff, share, parties, op_ids) {
+      for (var index = 0; index < parties.length; index++) {
+        var i = parties[index]; // Party id
+        if (i === jiff.id) {
+          receive_open(jiff, {party_id: i, share: share.value, op_id: op_ids[i], Zp: share.Zp});
+          continue;
         }
-      };
 
-      if (share.ready) {
-        if (typeof (share.value) === 'number') {
-          openresult = old_open(share, parties, op_ids);
-          open_deferred.resolve(openresult);
-        } else {
-          openresult = jiff_open();
-          open_deferred.resolve(openresult)
+        // encrypt, sign and send
+        var msg = {party_id: i, share: share.value.slice(), op_id: op_ids[i], Zp: share.Zp};
+        msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'open', msg], 2);
+        for (var j = 0; j < msg['share'].length; j++) {
+          msg['share'][j] = jiff.hooks.encryptSign(jiff, msg['share'][j].toString(), jiff.keymap[msg['party_id']], jiff.secret_key);
         }
-      } else {
-        share.promise.then(function () {
-          if (typeof (share.value) === 'number') {
-            openresult = old_open(share, parties, op_ids);
-            open_deferred.resolve(openresult)
-          } else {
-            openresult = jiff_open();
-            open_deferred.resolve(openresult)
-          }
-        }, share.error);
+        jiff.socket.safe_emit('open', JSON.stringify(msg));
       }
-
-    return open_promise;
-  };
+    }
 
     function receive_open(jiff, json_msg) {
       // Decrypt share
@@ -1644,234 +1555,315 @@
       jiff.deferreds[op_id][sender_id].resolve({value: share, sender_id: sender_id, Zp: Zp});
     }
 
-    function jiff_broadcast(jiff, share, parties, op_ids) {
-      for (var index = 0; index < parties.length; index++) {
-        var i = parties[index]; // Party id
-        if (i === jiff.id) {
-          receive_open(jiff, {party_id: i, share: share.value, op_id: op_ids[i], Zp: share.Zp});
-          continue;
-        }
+    jiff_open = function(jiff, share, parties, op_ids) {
+      var i;
 
-        // encrypt, sign and send
-        var msg = {party_id: i, share: share.value.slice(), op_id: op_ids[i], Zp: share.Zp};
-        msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'open', msg], 2);
+      if (!(share.jiff === jiff)) {
+        throw 'share does not belong to given instance';
+      }
 
-        for (var j = 0; j < msg['share'].length; j++) {
-          msg['share'][j] = jiff.hooks.encryptSign(jiff, msg['share'][j].toString(), jiff.keymap[msg['party_id']], jiff.secret_key);
+      // Default values
+      if (parties == null || parties === []) {
+        parties = [];
+        for (i = 1; i <= jiff.party_count; i++) {
+          parties.push(i);
         }
-        jiff.socket.safe_emit('open', JSON.stringify(msg));
+      } else {
+        parties.sort();
       }
-    }
-
 
-    function jiff_lagrange(jiff, shares) {
-      var lagrange_coeff = []; // will contain shares.length many elements.
+      // If not a receiver nor holder, do nothing
+      if (share.holders.indexOf(jiff.id) === -1 && parties.indexOf(jiff.id) === -1) {
+        return null;
+      }
 
-      // Compute the Lagrange coefficients at 0.
-      for (var i = 0; i < shares.length; i++) {
-        for (var share_num = 0; share_num < shares[i].value.length; share_num++) {
-          var pi = jiff.helpers.get_party_number(shares[i].sender_id, share_num);
-          lagrange_coeff[pi] = 1;
+      // Compute operation ids (one for each party that will receive a result
+      if (op_ids == null) {
+        op_ids = {};
+      }
 
-          for (var j = 0; j < shares.length; j++) {
-            for (var n = 0; n < shares[j].value.length; n++) {
-              var pj = jiff.helpers.get_party_number(shares[j].sender_id, n);
-              if (pj !== pi) {
-                var inv = jiff.helpers.extended_gcd(pi - pj, shares[i].Zp)[0];
-                lagrange_coeff[pi] = jiff.helpers.mod(lagrange_coeff[pi] * (0 - pj), shares[i].Zp) * inv;
-                lagrange_coeff[pi] = jiff.helpers.mod(lagrange_coeff[pi], shares[i].Zp);
-              }
-            }
+      if (typeof (op_ids) === 'string' || typeof (op_ids) === 'number') {
+        var tmp = {};
+        for (i = 0; i < parties.length; i++) {
+          tmp[parties[i]] = op_ids;
+        }
+        op_ids = tmp;
+      } else {
+        var holders_label = share.holders.join(',');
+        for (i = 0; i < parties.length; i++) {
+          if (op_ids[parties[i]] == null) {
+            op_ids[parties[i]] = jiff.counters.gen_open_id(parties[i], holders_label);
           }
         }
       }
 
-      // Reconstruct the secret via Lagrange interpolation
-      var recons_secret = 0;
-      for (var p = 0; p < shares.length; p++) {
-        for (share_num = 0; share_num < shares[p].value.length; share_num++) {
-          var party = jiff.helpers.get_party_number(shares[p].sender_id, share_num);
-          var tmp = jiff.helpers.mod((shares[p].value[share_num] * lagrange_coeff[party]), shares[p].Zp);
-          recons_secret = jiff.helpers.mod((recons_secret + tmp), shares[p].Zp);
+      // Party is a holder
+      if (share.holders.indexOf(jiff.id) > -1) {
+        // Call hook
+        share = jiff.execute_array_hooks('beforeOpen', [jiff, share, parties], 1);
+
+        // refresh/reshare, so that the original share remains secret, instead
+        // a new share is sent/open without changing the actual value.
+        //share = share.refresh('refresh:' + op_ids[parties[0]]);
+
+        // The given share has been computed, share it to all parties
+        if (share.ready) {
+          jiff_broadcast(jiff, share, parties, op_ids);
+        } else {
+          jiff.counters.pending_opens++;
+          // Share is not ready, setup sharing as a callback to its promise
+          share.promise.then(function () {
+            jiff.counters.pending_opens--;
+            jiff_broadcast(jiff, share, parties, op_ids);
+          }, share.error);
         }
       }
-      return recons_secret;
-    }
 
-    var old_share = jiff.share;
-    jiff.share = function (secret, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios) {
-      //receivers_ratios = {1: 2, 2: 2};
-      if (receivers_ratios == null){
-        var result = old_share(secret, threshold, receivers_list, senders_list, Zp, share_id);
-        return result;
-      } else {
-        var i, j, p_id, p_ratio;
+      // Party is a receiver
+      if (parties.indexOf(jiff.id) > -1) {
+        var shares = []; // this will store received shares
+        var numberofshares = 0;
+        var final_deferred = new Deferred(); // will be resolved when the final value is reconstructed
+        var final_promise = final_deferred.promise;
+        for (i = 0; i < share.holders.length; i++) {
+          var p_id = share.holders[i];
 
-        // defaults
-        if (Zp == null) {
-          Zp = jiff.Zp;
-        }
-        if (receivers_list == null) {
-          receivers_list = [];
-          for (i = 1; i <= jiff.party_count; i++) {
-            receivers_list.push(i);
+          // Setup a deferred for receiving a share from party p_id
+          if (jiff.deferreds[op_ids[jiff.id]] == null) {
+            jiff.deferreds[op_ids[jiff.id]] = {};
           }
-        }
-        if (senders_list == null) {
-          senders_list = [];
-          for (i = 1; i <= jiff.party_count; i++) {
-            senders_list.push(i);
+          if (jiff.deferreds[op_ids[jiff.id]][p_id] == null) {
+            jiff.deferreds[op_ids[jiff.id]][p_id] = new Deferred();
           }
+
+          // Clean up deferred when fulfilled
+          var promise = jiff.deferreds[op_ids[jiff.id]][p_id].promise;
+
+          // destroy deferred when done
+          (function (promise, p_id) { // p_id is modified in a for loop, must do this to avoid scoping issues.
+            promise.then(function (received_share) {
+              jiff.deferreds[op_ids[jiff.id]][p_id] = null;
+              shares.push(received_share);
+              numberofshares += received_share['value'].length;
+
+              // Too few shares, nothing to do.
+              if (numberofshares < share.threshold) {
+                return;
+              }
+
+              // Enough shares to reconstruct.
+              // If did not already reconstruct, do it.
+              if (final_deferred != null) {
+                var recons_secret = jiff_lagrange(jiff, shares);
+                recons_secret = jiff.execute_array_hooks('afterReconstructShare', [jiff, recons_secret], 1);
+                final_deferred.resolve(recons_secret);
+                final_deferred = null;
+              }
+
+              // If all shares were received, clean up.
+              if (shares.length === share.holders.length) {
+                shares = null;
+                jiff.deferreds[op_ids[jiff.id]] = null;
+              }
+            });
+          })(promise, p_id);
         }
-        if (threshold == null) {
-          threshold = receivers_list.length;
-        }
-        if (threshold < 0) {
-          threshold = 2;
+        return final_promise;
+      }
+    };
+
+
+    jiff.open = function (share, parties, op_ids) {
+      return jiff.internal_open(share, parties, op_ids);
+    };
+
+    jiff.internal_open = function (share, parties, op_ids) {
+      return jiff_open(jiff, share, parties, op_ids);
+    };
+
+    jiff.share = function (secret, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios) {
+      var i, j, p_id, p_ratio;
+
+      // defaults
+      if (Zp == null) {
+        Zp = jiff.Zp;
+      }
+      if (receivers_list == null) {
+        receivers_list = [];
+        for (i = 1; i <= jiff.party_count; i++) {
+          receivers_list.push(i);
         }
-        if (threshold > receivers_list.length) {
-          threshold = receivers_list.length;
+      }
+      if (senders_list == null) {
+        senders_list = [];
+        for (i = 1; i <= jiff.party_count; i++) {
+          senders_list.push(i);
         }
+      }
+      if (threshold == null) {
+        threshold = receivers_list.length;
+      }
+      if (threshold < 0) {
+        threshold = 2;
+      }
+      if (threshold > receivers_list.length) {
+        threshold = receivers_list.length;
+      }
+      if (receivers_ratios == null) {
+        receivers_ratios = {1: 2, 2: 1}
+      }
 
-        // if party is uninvolved in the share, do nothing
-        if (receivers_list.indexOf(jiff.id) === -1 && senders_list.indexOf(jiff.id) === -1) {
-          return {};
-        }
+      // if party is uninvolved in the share, do nothing
+      if (receivers_list.indexOf(jiff.id) === -1 && senders_list.indexOf(jiff.id) === -1) {
+        return {};
+      }
 
-        // compute operation id
-        receivers_list.sort(); // sort to get the same order
-        senders_list.sort();
-        if (share_id == null) {
-          share_id = jiff.counters.gen_share_id(receivers_list, senders_list);
-        }
+      // compute operation id
+      receivers_list.sort(); // sort to get the same order
+      senders_list.sort();
+      if (share_id == null) {
+        share_id = jiff.counters.gen_share_id(receivers_list, senders_list);
+      }
 
-        // stage sending of shares
-        if (senders_list.indexOf(jiff.id) > -1) {
-          // Call hook
-          secret = jiff.execute_array_hooks('beforeShare', [jiff, secret, threshold, receivers_list, senders_list, Zp], 1);
+      // stage sending of shares
+      if (senders_list.indexOf(jiff.id) > -1) {
+        // Call hook
+        secret = jiff.execute_array_hooks('beforeShare', [jiff, secret, threshold, receivers_list, senders_list, Zp], 1);
 
-          // compute shares
-          var shares = jiff_compute_shares(jiff, secret, receivers_list, threshold, Zp, receivers_ratios);
+        // compute shares
+        var shares = jiff_compute_shares(jiff, secret, receivers_list, threshold, Zp, receivers_ratios);
 
-          // Call hook
-          shares = jiff.execute_array_hooks('afterComputeShare', [jiff, shares, threshold, receivers_list, senders_list, Zp], 1);
+        // Call hook
+        shares = jiff.execute_array_hooks('afterComputeShare', [jiff, shares, threshold, receivers_list, senders_list, Zp], 1);
 
-          // send shares
-          for (i = 0; i < receivers_list.length; i++) {
-            p_id = receivers_list[i];
-            if (p_id === jiff.id) {
-              continue;
-            }
+        // send shares
+        for (i = 0; i < receivers_list.length; i++) {
+          p_id = receivers_list[i];
+          if (p_id === jiff.id) {
+            continue;
+          }
 
-            // send encrypted and signed shares_id[p_id] to party p_id
-            var msg = { party_id: p_id, share: shares[p_id], op_id: share_id, p_ratio: p_ratio};
-            msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'share', msg], 2);
-            p_ratio = (p_id in receivers_ratios) ? receivers_ratios[p_id] : 1;
-            for (j = 0; j < p_ratio; j++) {
-              msg['share'][j] = jiff.hooks.encryptSign(jiff, msg['share'][j].toString(10), jiff.keymap[msg['party_id']], jiff.secret_key);
-            }
-            jiff.socket.safe_emit('share', JSON.stringify(msg));
+          // send encrypted and signed shares_id[p_id] to party p_id
+          var msg = {party_id: p_id, share: shares[p_id], op_id: share_id, p_ratio: p_ratio};
+          msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'share', msg], 2);
+          p_ratio = (p_id in receivers_ratios) ? receivers_ratios[p_id] : 1;
+          for (j = 0; j < p_ratio; j++) {
+            msg['share'][j] = jiff.hooks.encryptSign(jiff, msg['share'][j].toString(10), jiff.keymap[msg['party_id']], jiff.secret_key);
           }
+          jiff.socket.safe_emit('share', JSON.stringify(msg));
         }
+      }
 
-        // stage receiving of shares
-        var result = {};
-        if (receivers_list.indexOf(jiff.id) > -1) {
-          // setup a map of deferred for every received share
-          if (jiff.deferreds[share_id] == null) {
-            jiff.deferreds[share_id] = {};
-          }
+      // stage receiving of shares
+      var result = {};
+      if (receivers_list.indexOf(jiff.id) > -1) {
+        // setup a map of deferred for every received share
+        if (jiff.deferreds[share_id] == null) {
+          jiff.deferreds[share_id] = {};
+        }
 
-          for (i = 0; i < senders_list.length; i++) {
-            p_id = senders_list[i];
-            p_ratio = (p_id in receivers_ratios) ? receivers_ratios[p_ratio] : 1;
-            if (p_id === jiff.id) {
-              var my_share = jiff.execute_array_hooks('receiveShare', [jiff, p_id, shares[p_id]], 2);
-              result[p_id] = jiff.secret_share(jiff, true, null, my_share, receivers_list, threshold, Zp);
-              continue; // Keep party's own share
-            }
+        for (i = 0; i < senders_list.length; i++) {
+          p_id = senders_list[i];
+          p_ratio = (p_id in receivers_ratios) ? receivers_ratios[p_ratio] : 1;
+          if (p_id === jiff.id) {
+            var my_share = jiff.execute_array_hooks('receiveShare', [jiff, p_id, shares[p_id]], 2);
+            result[p_id] = jiff.secret_share(jiff, true, null, my_share, receivers_list, threshold, Zp, null, receivers_ratios);
+            continue; // Keep party's own share
+          }
 
-            // check if a deferred is set up (maybe the message was previously received)
-            if (jiff.deferreds[share_id][p_id] == null) {
-              // not ready, setup a deferred
-              jiff.deferreds[share_id][p_id] = new Deferred();
-            }
+          // check if a deferred is set up (maybe the message was previously received)
+          if (jiff.deferreds[share_id][p_id] == null) {
+            // not ready, setup a deferred
+            jiff.deferreds[share_id][p_id] = new Deferred();
+          }
 
-            var promise = jiff.deferreds[share_id][p_id].promise;
+          var promise = jiff.deferreds[share_id][p_id].promise;
 
-            // destroy deferred when done
-            (function (promise, p_id) { // p_id is modified in a for loop, must do this to avoid scoping issues.
-              promise.then(function () {
-                jiff.deferreds[share_id][p_id] = null;
-              });
-            })(promise, p_id);
+          // destroy deferred when done
+          (function (promise, p_id) { // p_id is modified in a for loop, must do this to avoid scoping issues.
+            promise.then(function () {
+              jiff.deferreds[share_id][p_id] = null;
+            });
+          })(promise, p_id);
 
-            // receive share_i[id] from party p_id
-            result[p_id] = jiff.secret_share(jiff, false, promise, undefined, receivers_list, threshold, Zp, share_id + ':' + p_id);
-          }
+          // receive share_i[id] from party p_id
+          result[p_id] = jiff.secret_share(jiff, false, promise, undefined, receivers_list, threshold, Zp, share_id + ':' + p_id, receivers_ratios);
         }
-        return result;
       }
+      return result;
     };
 
-    function jiff_compute_shares(jiff, secret, parties_list, threshold, Zp, parties_ratios) {
-      var shares = {}; // Keeps the shares
-      var i;
-      // Each player's random polynomial f must have
-      // degree threshold - 1, so that threshold many points are needed
-      // to interpolate/reconstruct.
-      var t = threshold - 1;
-      var polynomial = Array(t + 1); // stores the coefficients
 
-      // Each players's random polynomial f must be constructed
-      // such that f(0) = secret
-      polynomial[0] = secret;
+    function jiff_triplet(jiff, receivers_list, threshold, Zp, triplet_id, receivers_ratios) {
+      if (Zp == null) {
+        Zp = jiff.Zp;
+      }
+      if (receivers_list == null) {
+        receivers_list = [];
+        for (var i = 1; i <= jiff.party_count; i++) {
+          receivers_list.push(i);
+        }
+      }
+      if (threshold == null) {
+        threshold = receivers_list.length;
+      }
 
-      // Compute the random polynomial f's coefficients
-      for (i = 1; i <= t; i++) {
-        polynomial[i] = jiff.helpers.random(Zp);
+      // Get the id of the triplet needed.
+      if (triplet_id == null) {
+        triplet_id = jiff.counters.gen_triplet_id(receivers_list);
       }
 
-      // Compute each players share such that share[i] = f(i)
-      for (i = 0; i < parties_list.length; i++) {
-        var p_id = parties_list[i];
-        var p_ratio = p_id in parties_ratios ? parties_ratios[p_id] : 1;
-        shares[p_id] = [];
-        for (var share_num = 0; share_num < p_ratio; share_num++) {
-          shares[p_id][share_num] = polynomial[0];
-          var power = jiff.helpers.get_party_number(p_id, share_num);
-
-          for (var j = 1; j < polynomial.length; j++) {
-            var tmp = jiff.helpers.mod((polynomial[j] * power), Zp);
-            shares[p_id][share_num] = jiff.helpers.mod((shares[p_id][share_num] + tmp), Zp);
-            power = jiff.helpers.mod(power * jiff.helpers.get_party_number(p_id, share_num), Zp);
-          }
-        }
+      // Send a request to the server.
+      var msg = { triplet_id: triplet_id, receivers: receivers_list, threshold: threshold, Zp: Zp, ratios: receivers_ratios};
+      msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'triplet', msg], 2);
+      msg = JSON.stringify(msg);
+
+      // Setup deferred to handle receiving the triplets later.
+      var a_deferred = new Deferred();
+      var b_deferred = new Deferred();
+      var c_deferred = new Deferred();
+      jiff.deferreds[triplet_id] = {a: a_deferred, b: b_deferred, c: c_deferred};
+
+      // send a request to the server.
+      if (jiff.id === 's1') {
+        jiff.socket.safe_emit('triplet', msg);
+      } else {
+        var cipher = jiff.hooks.encryptSign(jiff, msg, jiff.keymap['s1'], jiff.secret_key);
+        jiff.socket.safe_emit('triplet', JSON.stringify(cipher));
       }
-      return shares;
+
+      var a_share = jiff.secret_share(jiff, false, a_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':a');
+      var b_share = jiff.secret_share(jiff, false, b_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':b');
+      var c_share = jiff.secret_share(jiff, false, c_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':c');
+
+      return [a_share, b_share, c_share];
     }
 
+    jiff.triplet = function (receivers_list, threshold, Zp, triplet_id, receivers_ratios) {
+      return jiff_triplet(jiff, receivers_list, threshold, Zp, triplet_id, receivers_ratios);
+    };
+
 
     /* HOOKS */
-    jiff.helpers.get_party_number = function (party_id, share_num) {
-      if (share_num == null){
-        share_num = 0;
-      }
-      if (typeof(party_id) === 'number') {
-        return party_id + (share_num * (jiff.party_count+1));
-      }
-      if (party_id.startsWith('s')) {
-        return parseInt(party_id.substring(1), 10) * (jiff.party_count+1); // n+1 reserved for server
+    jiff.hooks.createSecretShare.push(createMultipleSharesSecretShare);
+    // parse content of share/open messages to be integers
+    jiff.hooks.afterOperation[0] = function (jiff, label, msg) {
+      if (label === 'share' || label === 'open') {
+        if (msg['share'].length >= 1) {
+          for (var i = 0; i < msg['share'].length; i++) {
+            msg['share'][i] = parseInt(msg['share'][i], 10);
+          }
+        } else {
+          msg['share'] = parseInt(msg['share'], 10);
+        }
       }
-      return parseInt(party_id, 10) + (share_num * (jiff.party_count+1));
+      return msg;
     };
 
-    jiff.hooks.createSecretShare.push(createMultipleSharesSecretShare);
-    jiff.hooks.afterOperation.push(afterOperationMultipleShares);
     return jiff;
   }
 
   // Expose API
   exports.make_jiff = make_jiff;
-
+  exports.sharing_schemes = {shamir_share: jiff_compute_shares, shamir_reconstruct: jiff_lagrange};
 }((typeof exports === 'undefined' ? this.jiff_asynchronousshare = {} : exports), typeof exports !== 'undefined'));
\ No newline at end of file
diff --git a/lib/ext/temp.js b/lib/ext/temp.js
new file mode 100644
index 000000000..1affcc00c
--- /dev/null
+++ b/lib/ext/temp.js
@@ -0,0 +1,54 @@
+share.smult = function (o, op_id) {
+  var final_deferred = new Deferred();
+  var final_promise = final_deferred.promise;
+
+  var ready_mult = function () {
+    var result = [];
+    var promises = [];
+    for (var i = 0; i < share.value.length; i++) {
+      var share_tmp = jiff.secret_share(share.jiff, true, null, share.value[i], share.holders, share.threshold, share.Zp);
+      var o_tmp = jiff.secret_share(o.jiff, true, null, o.value[i], o.holders, o.threshold, o.Zp);
+      var multshare = share_tmp.legacy.smult(o_tmp, op_id + ':' + i);
+      promises.push(multshare.promise);
+
+      //var cb = function (i, multshare) {
+      //  result[i] = multshare.value;
+      //};
+      //multshare.promise.then(cb.bind(null, i, multshare));
+
+      multshare.promise.then((function (i, multshare){
+        result[i] = multshare.value;
+      }).bind(null, i, multshare));
+    }
+
+    Promise.all(promises).then(function () {
+      console.log(result);
+      final_deferred.resolve(result);
+    }, share.error);
+  };
+
+  if (share.ready && o.ready) {
+    if (typeof (share.value) === 'number') {
+      var res = share.legacy.smult(o, op_id);
+      res.promise.then(function () {
+        final_deferred.resolve(res.value);
+      });
+    } else {
+      ready_mult();
+    }
+  }
+
+  // promise to execute ready_add when both are ready
+  share.pick_promise(o).then(function () {
+    if (typeof (share.value) === 'number') {
+      var res = share.legacy.smult(o, op_id);
+      res.promise.then(function () {
+        final_deferred.resolve(res.value);
+      });
+    } else {
+      ready_mult();
+    }
+  }, share.error);
+
+  return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+};
\ No newline at end of file
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index 52fa64e80..af1795fa3 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -177,12 +177,12 @@
    * @return {object} the secret share object containing the give value.
    *
    */
-  function many_secret_shares(jiff, count, holders, threshold, Zp, id) {
+  function many_secret_shares(jiff, count, holders, threshold, Zp, id, ratios) {
     var deferreds = [];
     var shares = [];
     for (var i = 0; i < count; i++) {
       var deferred = new Deferred();
-      shares.push(jiff.secret_share(jiff, false, deferred.promise, undefined, holders, threshold, Zp, 'share:' + i + ':' + id));
+      shares.push(jiff.secret_share(jiff, false, deferred.promise, undefined, holders, threshold, Zp, 'share:' + i + ':' + id, ratios));
       deferreds.push(deferred);
     }
 
@@ -415,7 +415,6 @@
         power = jiff.helpers.mod(power * jiff.helpers.get_party_number(p_id), Zp);
       }
     }
-
     return shares;
   }
 
@@ -591,6 +590,7 @@
    *
    */
   function jiff_broadcast(jiff, share, parties, op_ids) {
+
     for (var index = 0; index < parties.length; index++) {
       var i = parties[index]; // Party id
       if (i === jiff.id) {
@@ -601,7 +601,6 @@
       // encrypt, sign and send
       var msg = {party_id: i, share: share.value, op_id: op_ids[i], Zp: share.Zp};
       msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'open', msg], 2);
-
       msg['share'] = jiff.hooks.encryptSign(jiff, msg['share'].toString(), jiff.keymap[msg['party_id']], jiff.secret_key);
       jiff.socket.safe_emit('open', JSON.stringify(msg));
     }
@@ -738,6 +737,7 @@
     var a_share = jiff.secret_share(jiff, false, a_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':a');
     var b_share = jiff.secret_share(jiff, false, b_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':b');
     var c_share = jiff.secret_share(jiff, false, c_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':c');
+
     return [a_share, b_share, c_share];
   }
 
@@ -749,10 +749,8 @@
    */
   function receive_triplet(jiff, json_msg) {
     json_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'triplet', json_msg], 2);
-
     var triplet = json_msg['triplet'];
     var triplet_id = json_msg['triplet_id'];
-
     if (jiff.deferreds[triplet_id] == null) {
       return;
     }
@@ -1613,7 +1611,7 @@
      * @instance
      */
     self.refresh = function (op_id) {
-      return self.isadd(self.jiff.server_generate_and_share({number: 0}, self.holders, self.threshold, self.Zp, op_id)[0]);
+      return self;//self.isadd(self.jiff.server_generate_and_share({number: 0}, self.holders, self.threshold, self.Zp, op_id)[0]);
     };
 
     /**
@@ -1987,6 +1985,7 @@
         throw new Error('shares must be held by the same parties (+)');
       }
 
+
       // add the two shares when ready locally
       var ready_add = function () {
         return self.jiff.helpers.mod(share_helpers['+'](self.value, o.value), self.Zp);
@@ -2086,7 +2085,6 @@
       Promise.all([e_promise, d_promise]).then(function (arr) {
         var e_open = arr[0];
         var d_open = arr[1];
-
         // result_share = d_open * e_open + d_open * b_share + e_open * a_share + c.
         var t1 = self.jiff.helpers.mod(share_helpers['*'](d_open, e_open), self.Zp);
         var t2 = b.icmult(d_open);
@@ -2140,11 +2138,11 @@
       var result = self.jiff.secret_share(self.jiff, false, final_promise, undefined, self.holders, max(self.threshold, o.threshold), self.Zp, 'share:' + op_id);
 
       Promise.all([self.promise, o.promise]).then(
-        function () {
-          // Get Shares  of z
-          var zi = self.jiff.helpers.mod(share_helpers['*'](self.value, o.value), self.Zp);
-          final_deferred.resolve(zi);
-        });
+       function () {
+        // Get Shares  of z
+        var zi = self.jiff.helpers.mod(share_helpers['*'](self.value, o.value), self.Zp);
+        final_deferred.resolve(zi);
+      });
 
       return result.change_threshold(max(self.threshold, o.threshold), op_id + ':threshold');
     };
@@ -2878,6 +2876,7 @@
       // generate the bits of a random number less than our prime
       var bits = self.jiff.protocols.bits.rejection_sampling(0, self.Zp, self.threshold, self.holders, self.Zp, op_id + ':sampling');
       var r = self.jiff.protocols.bits.bit_composition(bits);
+
       // add and reveal random number to self
       self.jiff.internal_open(r.isadd(self), self.holders, op_id + ':open').then(function (result) {
         // compute bits assuming r+self < Zp
@@ -2894,7 +2893,6 @@
         }
         resolve_many_secrets(deferreds, withWrap);
       });
-
       return result;
     };
 
@@ -3462,6 +3460,7 @@
       return msg;
     });
 
+
     /**
      * Execute all hooks attached to the given name in order.
      * Hooks are executed sequentially such that the first hook's return value is passed into the second and so on.
@@ -4557,12 +4556,16 @@
      * @returns {SecretShare} a secret share of the number represented by bits.
      */
     jiff.protocols.bits.bit_composition = function (bits) {
+      //console.log('bits', bits);
       var result = bits[0];
       var pow = 1;
       for (var i = 1; i < bits.length; i++) {
         pow = pow * 2;
         result = result.isadd(bits[i].icmult(pow));
       }
+      //result.promise.then(function () {
+      //  console.log('result', result.value);
+      //})
       return result;
     };
 
@@ -6240,7 +6243,6 @@
         msg = jiff.hooks.decryptSign(jiff, msg, jiff.secret_key, jiff.keymap['s1']);
         msg = JSON.parse(msg);
       }
-
       // parse message
       receive_triplet(jiff, msg);
     });
diff --git a/tests/suite/computations.js b/tests/suite/computations.js
index e95e1e01c..3722be4d6 100644
--- a/tests/suite/computations.js
+++ b/tests/suite/computations.js
@@ -44,7 +44,8 @@ exports.mod = function (x, y) {
 // How to interpret MPC operations
 exports.mpcInterpreter = {
   '+': function (operand1, operand2) {
-    return operand1.add(operand2);
+    var result = operand1.add(operand2);
+    return result;
   },
   '-': function (operand1, operand2) {
     return operand1.sub(operand2);
@@ -190,9 +191,11 @@ exports.singleCompute = function (jiff_instance, shareParameters, test, values,
 
     // Compute
     var result = func(values[indices[0]], values[indices[1]]);
-    for (var i = 2; i < indices.length; i++) {
-      result = func(result, values[indices[i]]);
-    }
+
+    //for (var i = 2; i < indices.length; i++) {
+    //  result = func(result, values[indices[i]]);
+    //}
+
     return result;
   } catch (err) {
     console.log(err);
@@ -236,7 +239,6 @@ exports.singleTest = async function (jiff_instance, test, testInputs) {
     errors.push(err);
     return false;
   }
-
   return true;
 };
 
diff --git a/tests/suite/config/asyncShare/arithmetic.json b/tests/suite/config/asyncShare/arithmetic.json
index 01d76ccba..10166b9b4 100644
--- a/tests/suite/config/asyncShare/arithmetic.json
+++ b/tests/suite/config/asyncShare/arithmetic.json
@@ -1,5 +1,5 @@
 {
-  "tests": [ "+", "-", "*", "*bgw", "|", "^", "!", "abs", "/", "%" ],
+  "tests": [ "*" ],
   "suiteConf": {
     "port": 3001,
     "extensions": [ "asyncShare" ],
@@ -15,31 +15,23 @@
 
   "testConf": {
     "default": {
-      "count": 100,
+      "count": 10,
       "parallel": 25,
       "options": {
         "Zp": 15485867,
-        "party_count": 3
+        "party_count": 4
       }
     },
     "*bgw": {
-      "count": 100,
+      "count": 1,
       "parallel": 25,
       "options": {
         "Zp": 15485867,
-        "party_count": 4
-      }
-    },
-    "abs": {
-      "count": 10,
-      "parallel": 3,
-      "options": {
-        "Zp": 127,
         "party_count": 3
       }
     },
     "/": {
-      "count": 8,
+      "count": 1,
       "parallel": 3,
       "options": {
         "Zp": 127,
diff --git a/tests/suite/config/asyncShare/comparison.json b/tests/suite/config/asyncShare/comparison.json
index 42d034204..0b178bade 100644
--- a/tests/suite/config/asyncShare/comparison.json
+++ b/tests/suite/config/asyncShare/comparison.json
@@ -1,5 +1,5 @@
 {
-  "tests": [ "<", "<=", ">", ">=", "==", "!=" ],
+  "tests": [ "<","<=", ">", ">=", "==", "!=" ],
   "suiteConf": {
     "port": 3001,
     "extensions": ["asyncShare"],
diff --git a/tests/suite/config/asyncShare/computations.js b/tests/suite/config/asyncShare/computations.js
index 0b614af4a..3f2ba7590 100644
--- a/tests/suite/config/asyncShare/computations.js
+++ b/tests/suite/config/asyncShare/computations.js
@@ -1,60 +1,85 @@
+// Acquire Zp from the jiff instance
+var Zp;
+
+// Flags success/failure
+var errors = [];
+var successes = [];
+
 // Override with different interpreters
 var baseComputations = require('../../computations.js');
 
-// How to interpret non-MPC operations
-baseComputations.openInterpreter['+'] = function (operand1, operand2) {
-  return operand1 + operand2;
-};
-baseComputations.openInterpreter['-'] = function (operand1, operand2) {
-  return operand1 - operand2;
-};
-baseComputations.openInterpreter['*'] = function (operand1, operand2) {
-  return operand1 * operand2;
-};
-baseComputations.openInterpreter['*bgw'] = function (operand1, operand2) {
-  return operand1 * operand2;
-};
-baseComputations.openInterpreter['^'] = function (operand1, operand2) {
-  return operand1 ^ operand2;
-};
-baseComputations.openInterpreter['|'] = function (operand1, operand2) {
-  return operand1 | operand2;
-};
-baseComputations.openInterpreter['/'] = function (operand1, operand2) {
-  return Math.floor(operand1 / operand2);
-};
-baseComputations.openInterpreter['%'] = function (operand1, operand2) {
-  return operand1 % operand2;
-};
-baseComputations.openInterpreter['<'] = function (operand1, operand2) {
-  return Number(operand1 < operand2);
-};
-baseComputations.openInterpreter['<='] = function (operand1, operand2) {
-  return Number(operand1 <= operand2);
-};
-baseComputations.openInterpreter['>'] = function (operand1, operand2) {
-  return Number(operand1 > operand2);
-};
-baseComputations.openInterpreter['>='] = function (operand1, operand2) {
-  return Number(operand1 >= operand2);
-};
-baseComputations.openInterpreter['=='] = function (operand1, operand2) {
-  return Number(operand1 === operand2);
-};
-baseComputations.openInterpreter['!='] = function (operand1, operand2) {
-  return Number(operand1 !== operand2);
-};
-baseComputations.openInterpreter['!'] = function (operand1, _) {
-  return (operand1 + 1) % 2;
-};
-baseComputations.openInterpreter['abs'] = function (operand1, _) {
-  return Math.abs(operand1);
+var testConfig;
+
+
+// sharing
+baseComputations.shareHook = async function (jiff_instance, test, testInputs, input, threshold, receivers, senders, ratios) {
+  var shares = jiff_instance.share(input, threshold, receivers, senders, jiff_instance.Zp, null, ratios);
+  return shares;
+}
+
+baseComputations.shareParameters = function (jiff_instance, test, testInputs) {
+  var ratios = testInputs[1];
+  testInputs = testInputs[0];
+  var input = testInputs[jiff_instance.id];
+
+  // Figure out who is sharing
+  var senders = [];
+  for (var p in testInputs) {
+    if (testInputs.hasOwnProperty(p) && p != 'constant') {
+      senders.push(/^\d+$/.test(p.toString()) ? parseInt(p) : p);
+    }
+  }
+  senders.sort();
+
+  // Figure out threshold
+  var threshold = test === '*bgw' ? Math.floor(jiff_instance.party_count / 2) : jiff_instance.party_count;
+  return {input: input, threshold: threshold, senders: senders, receivers: null, constant: testInputs['constant'], ratios: ratios};
 };
 
-// Add new functionality to the MPC interpreter
-baseComputations.mpcInterpreter['abs'] = function (operand1, _) {
-  return operand1.abs();
+baseComputations.singleTest = async function (jiff_instance, test, testInputs) {
+  try {
+    // Share for MPC
+    var shareParameters = baseComputations.shareParameters(jiff_instance, test, testInputs);
+    var shares = await baseComputations.shareHook(jiff_instance, test, testInputs, shareParameters.input, shareParameters.threshold, shareParameters.receivers, shareParameters.senders, {1: 2, 2: 2, 3: 1, 4: 2});
+    if (shares == null) {
+      return null;
+    }
+
+    shares['constant'] = shareParameters.constant;
+
+    // Compute in the Open
+    var actualResult = await baseComputations.singleCompute(jiff_instance, shareParameters, test, testInputs[0], baseComputations.openInterpreter);
+
+    // Compute under MPC
+    var mpcResult = await baseComputations.singleCompute(jiff_instance, shareParameters, test, shares, baseComputations.mpcInterpreter);
+    if (mpcResult == null) {
+      return null;
+    }
+
+    // Open
+    mpcResult = await baseComputations.openHook(jiff_instance, test, mpcResult);
+
+    // Verify result
+    // Assert both results are equal
+    if (!baseComputations.verifyResultHook(test, mpcResult, actualResult)) {
+      errors.push(baseComputations.errorMessage(jiff_instance, test, testInputs[0], shareParameters, mpcResult, actualResult));
+      return false;
+    }
+
+    successes.push(baseComputations.successMessage(jiff_instance, test, testInputs[0], shareParameters, mpcResult, actualResult));
+  } catch (err) {
+    console.log(err);
+    errors.push(err);
+    return false;
+  }
+
+  return true;
 };
 
 // Default Computation Scheme
-module.exports = baseComputations;
\ No newline at end of file
+exports.compute = function (_jiff_instance, _test, _inputs, _testParallel, _done, _testConfig) {
+  testConfig = _testConfig;
+  return baseComputations.compute.apply(baseComputations, arguments);
+};
+
+
diff --git a/tests/suite/config/asyncShare/constant arithmetic.json b/tests/suite/config/asyncShare/constant arithmetic.json
index f35d2a24a..b02ba006b 100644
--- a/tests/suite/config/asyncShare/constant arithmetic.json	
+++ b/tests/suite/config/asyncShare/constant arithmetic.json	
@@ -15,7 +15,7 @@
 
   "testConf": {
     "default": {
-      "count": 100,
+      "count": 1,
       "parallel": 50,
       "options": {
         "Zp": 15485867,
diff --git a/tests/suite/config/asyncShare/generation.js b/tests/suite/config/asyncShare/generation.js
index a696727d6..d8c671ae0 100644
--- a/tests/suite/config/asyncShare/generation.js
+++ b/tests/suite/config/asyncShare/generation.js
@@ -1,24 +1,56 @@
-exports.generateUniform = function (test, options, max) {
-  return Math.floor(Math.random() * max);
-};
-exports.generateNonZeroUniform = function (test, options, max) {
-  return Math.floor(Math.random() * (max - 1)) + 1;
-};
-exports.generateBit = function (/*test, options*/) {
-  return Math.random() < 0.5 ? 0 : 1;
-};
-exports.generateMultiple = function (test, options, max, factor) {
-  var coef = exports.generateUniform(test, options, Math.floor(max / factor));
-  return coef * factor;
+// Reuse base generation but with different underlying generation methods
+var baseGeneration = require('../base/generation.js');
+
+// Sharing/Opening test cases with no operations
+baseGeneration.generateShareRatios = function(test, count, options){
+  var t, p, oneRatio;
+  var inputs = [];
+  var threshold = Math.floor(Math.random() * options.party_count) + 1;
+  for (t = 0; t < count; t++) {
+    oneRatio = {};
+    for (p = 1; p <= options.party_count; p++) {
+      oneRatio[p] = baseGeneration.generateNonZeroUniform(test, options, threshold);
+    }
+    inputs.push(oneRatio);
+  }
+  return inputs;
 };
-exports.generateDividend = function (test, options, max, divisor) {
-  return exports.generateUniform(test, options, max);
+
+var oldArithmeticInputs = baseGeneration.generateArithmeticInputs;
+baseGeneration.generateArithmeticInputs = function (test, count, options) {
+  var inputs = [];
+  var arithInputs = oldArithmeticInputs(test, count, options);
+  var ratioInputs = baseGeneration.generateShareRatios(test,count,options);
+  for (var t = 0; t < count; t++) {
+    inputs.push([arithInputs[t], ratioInputs[t]]);
+  }
+  return inputs;
 };
 
-// Generation API referred to from configuration JSON files
+var oldConstantArithmeticInputs = baseGeneration.generateConstantArithmeticInputs;
+baseGeneration.generateConstantArithmeticInputs = function (test, count, options) {
+  var inputs = [];
+  var arithInputs = oldConstantArithmeticInputs(test, count, options);
+  var ratioInputs = baseGeneration.generateShareRatios(test,count,options);
+  for (var t = 0; t < count; t++) {
+    inputs.push([arithInputs[t], ratioInputs[t]]);
+  }
+  return inputs;
+}
 
-// Sharing/Opening test cases with no operations
-exports.generateShareInputs = function (test, count, options) {
+var oldComparisonInputs = baseGeneration.generateComparisonInputs;
+baseGeneration.generateComparisonInputs = function (test, count, options) {
+  var inputs = [];
+  var arithInputs = oldComparisonInputs(test, count, options);
+  var ratioInputs = baseGeneration.generateShareRatios(test,count,options);
+  for (var t = 0; t < count; t++) {
+    inputs.push([arithInputs[t], ratioInputs[t]]);
+  }
+  return inputs;
+}
+
+
+baseGeneration.generateShareInputs = function (test, count, options) {
   var all_parties = [];
   for (var k = 1; k <= options.party_count; k++) {
     all_parties.push(k);
@@ -36,7 +68,7 @@ exports.generateShareInputs = function (test, count, options) {
     var oneTest = { numbers: {} };
     // Generate numbers
     for (var p = 1; p <= options.party_count; p++) {
-      oneTest['numbers'][p] = exports.generateUniform(test, options, max);
+      oneTest['numbers'][p] = baseGeneration.generateUniform(test, options, max);
     }
     // 1 <= Threshold <= party_count
     oneTest['threshold'] = Math.floor(Math.random() * options.party_count) + 1;
@@ -59,132 +91,14 @@ exports.generateShareInputs = function (test, count, options) {
     oneTest['senders'] = senders;
     oneTest['receivers'] = receivers;
 
-    inputs.push(oneTest);
-  }
-  return inputs;
-};
-
-// Arithmetic inputs: one for each party except for / and % where only two inputs are needed.
-// | and ^ requires bits, while thr denominator for / and % must be non-zero.
-exports.generateArithmeticInputs = function (test, count, options) {
-  var party_count = options.party_count;
-  var max = options.max || options.Zp;
-
-  var inputs = [];
-  var t, p, oneInput;
-  if (test.startsWith('/') || test === '%') {
-    // division and mod: only two inputs, the second is non-zero.
-    for (t = 0; t < count; t++) {
-      oneInput = {};
-      oneInput[2] = exports.generateNonZeroUniform(test, options, max);
-      oneInput[1] = exports.generateDividend(test, options, max, oneInput[2]);
-      inputs.push(oneInput);
-    }
-  } else if (test === '|' || test === '^') {
-    // or and xor: inputs are binary
-    for (t = 0; t < count; t++) {
-      oneInput = {};
-      for (p = 1; p <= party_count; p++) {
-        oneInput[p] = exports.generateBit(test, options);
-      }
-      inputs.push(oneInput);
-    }
-  } else if (test === '!') {
-    for (t = 0; t < count; t++) {
-      oneInput = {};
-      oneInput[1] = exports.generateBit(test, options);
-      inputs.push(oneInput);
-    }
-    return inputs;
-  } else {
-    // otherwise no constraints
-    for (t = 0; t < count; t++) {
-      oneInput = {};
-      for (p = 1; p <= party_count; p++) {
-        oneInput[p] = exports.generateUniform(test, options, max);
-      }
-      inputs.push(oneInput);
-    }
-  }
-
-  return inputs;
-};
-
-// Constant Arithmetic inputs: an input for the first party, and a constant input.
-// | and ^ requires bits, while thr denominator for / and % must be non-zero.
-exports.generateConstantArithmeticInputs = function (test, count, options) {
-  var max = options.max || options.Zp;
-  var cmax = options.cmax || max;
-
-  var inputs = [];
-  var t, oneInput;
-  if (test.indexOf('/') > -1 || test.indexOf('%') > -1 || test === 'cdivfac') {
-    // division and mod: only two inputs, the second is non-zero.
-    for (t = 0; t < count; t++) {
-      oneInput = {};
-      oneInput['constant'] = exports.generateNonZeroUniform(test, options, cmax);
-      if (test === 'cdivfac') {
-        oneInput[1] = exports.generateMultiple(test, options, max, oneInput['constant']);
-      } else {
-        oneInput[1] = exports.generateDividend(test, options, max, oneInput['constant']);
-      }
-
-      inputs.push(oneInput);
+    // Generate receiver ratios between 1 <= threshold
+    for (p = 1; p < receivers; p++) {
+      oneTest['receiver_ratios'][p] = baseGeneration.generateUniform(test, options, oneTest['threshold']);
     }
-  } else if (test === '|' || test === '^') {
-    // or and xor: inputs are binary
-    for (t = 0; t < count; t++) {
-      oneInput = {};
-      oneInput[1] = exports.generateBit(test, options);
-      oneInput['constant'] = exports.generateBit(test, options);
-      inputs.push(oneInput);
-    }
-  } else {
-    // otherwise no constraints
-    for (t = 0; t < count; t++) {
-      oneInput = {};
-      oneInput[1] = exports.generateUniform(test, options, max);
-      oneInput['constant'] = exports.generateUniform(test, options, cmax);
-      inputs.push(oneInput);
-    }
-  }
 
-  return inputs;
-};
-
-// Constant Comparison inputs: two inputs for the first two parties only
-// if using random numbers and large Zp, inputs will be very unlikely to be equal
-// we must make it likely for the inputs to be equal manually for == and != checks
-exports.generateComparisonInputs = function (test, count, options) {
-  var max = options.max || options.Zp;
-
-  var inputs = [];
-  // make it likely that the numbers are equal.
-  for (var t = 0; t < count; t++) {
-    var oneInput = {};
-    oneInput[1] = exports.generateUniform(test, options, max);
-    oneInput[2] = Math.random() < 0.5 ? oneInput[1] : exports.generateUniform(test, options, max);
-    inputs.push(oneInput);
+    inputs.push(oneTest);
   }
-
   return inputs;
 };
 
-// Constant Comparison inputs: an input for the first party, and a constant input.
-// if using random numbers and large Zp, inputs will be very unlikely to be equal
-// we must make it likely for the inputs to be equal manually for == and != checks
-exports.generateConstantComparisonInputs = function (test, count, options) {
-  var max = options.max || options.Zp;
-  var cmax = options.cmax || max;
-
-  var inputs = [];
-  // make it likely that the numbers are equal.
-  for (var t = 0; t < count; t++) {
-    var oneInput = {};
-    oneInput[1] = exports.generateUniform(test, options, max);
-    oneInput['constant'] = Math.random() < 0.5 ? oneInput[1] : exports.generateUniform(test, options, cmax);
-    inputs.push(oneInput);
-  }
-
-  return inputs;
-};
+module.exports = baseGeneration;
\ No newline at end of file
diff --git a/tests/suite/config/bits/computations.js b/tests/suite/config/bits/computations.js
index d0c66434f..879849009 100644
--- a/tests/suite/config/bits/computations.js
+++ b/tests/suite/config/bits/computations.js
@@ -1,3 +1,8 @@
+
+// Flags success/failure
+var errors = [];
+var successes = [];
+
 // Use base computation but override interpreters.
 var baseComputations = require('../../computations.js');
 
@@ -142,10 +147,10 @@ baseComputations.mpcInterpreter = {
 };
 
 // Sharing bits
-baseComputations.shareHook = async function (jiff_instance, test, testInputs, input, threshold, receivers, senders) {
+baseComputations.shareHook = async function (jiff_instance, test, testInputs, input, threshold, receivers, senders, ratios) {
   var shares;
   if (testConfig['share'] == null || testConfig['share'] === 'decomposition') {
-    shares = jiff_instance.share(input, threshold, receivers, senders);
+    shares = jiff_instance.share(input, threshold, receivers, senders, jiff_instance.Zp, null, ratios);
     var i, pid;
     for (i = 0; i < senders.length; i++) {
       pid = senders[i];
@@ -195,6 +200,46 @@ baseComputations.verifyResultHook = function (test, mpcResult, expectedResult) {
   return (mpcResult.toString() === expectedResult.toString());
 };
 
+baseComputations.singleTest = async function (jiff_instance, test, testInputs) {
+  try {
+    // Share for MPC
+    var shareParameters = baseComputations.shareParameters(jiff_instance, test, testInputs);
+    var shares = await baseComputations.shareHook(jiff_instance, test, testInputs, shareParameters.input, shareParameters.threshold, shareParameters.receivers, shareParameters.senders, {1: 2, 2: 2, 3: 1, 4: 2});
+    if (shares == null) {
+      return null;
+    }
+
+    shares['constant'] = shareParameters.constant;
+
+    // Compute in the Open
+    var actualResult = await baseComputations.singleCompute(jiff_instance, shareParameters, test, testInputs[0], baseComputations.openInterpreter);
+
+    // Compute under MPC
+    var mpcResult = await baseComputations.singleCompute(jiff_instance, shareParameters, test, shares, baseComputations.mpcInterpreter);
+    if (mpcResult == null) {
+      return null;
+    }
+
+    // Open
+    mpcResult = await baseComputations.openHook(jiff_instance, test, mpcResult);
+
+    // Verify result
+    // Assert both results are equal
+    if (!baseComputations.verifyResultHook(test, mpcResult, actualResult)) {
+      errors.push(baseComputations.errorMessage(jiff_instance, test, testInputs[0], shareParameters, mpcResult, actualResult));
+      return false;
+    }
+
+    successes.push(baseComputations.successMessage(jiff_instance, test, testInputs[0], shareParameters, mpcResult, actualResult));
+  } catch (err) {
+    console.log(err);
+    errors.push(err);
+    return false;
+  }
+
+  return true;
+};
+
 // Default Computation Scheme
 exports.compute = function (_jiff_instance, _test, _inputs, _testParallel, _done, _testConfig) {
   testConfig = _testConfig;
diff --git a/tests/suite/config/bits/decomposition.json b/tests/suite/config/bits/decomposition.json
index c33dfd110..3274a2619 100644
--- a/tests/suite/config/bits/decomposition.json
+++ b/tests/suite/config/bits/decomposition.json
@@ -3,6 +3,7 @@
              "decomposition-open-2-15485867", "decomposition-open-3-15485867", "decomposition-open-5-2039" ],
   "suiteConf": {
     "port": 3001,
+    "extensions" : ["asyncShare"],
     "generation": {
       "file": "config/bits/generation.js",
       "function": "generateDecomposition"
diff --git a/tests/suite/server.js b/tests/suite/server.js
index 8c3ca9b8e..73732c428 100644
--- a/tests/suite/server.js
+++ b/tests/suite/server.js
@@ -1,4 +1,5 @@
 var extensions = process.env['JIFF_TEST_NAME'];
+console.log(extensions);
 
 var express = require('express');
 var app = express();
@@ -7,6 +8,7 @@ var http = require('http').Server(app);
 var jiffServer = require('../../lib/jiff-server');
 var jiffRestAPIServer =  require('../../lib/ext/jiff-server-restful');
 var jiffBigNumberServer = require('../../lib/ext/jiff-server-bignumber');
+var jiffAsyncShareServer = require('../../lib/ext/jiff-server-asyncshare');
 
 var options = {
   logs: true,
@@ -23,6 +25,10 @@ if (extensions != null && extensions.indexOf('restAPI') > -1) {
   app.use(bodyParser.json());
   jiff_instance.apply_extension(jiffRestAPIServer, options);
 }
+if (extensions != null && extensions.indexOf('asyncShare') > -1) {
+  console.log('async extension server');
+  jiff_instance.apply_extension(jiffAsyncShareServer, options);
+}
 
 // Serve static files.
 app.use('/demos', express.static('demos'));

From 354490ccc141703beb2ed6b9cf28dd8a58451e0c Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Thu, 18 Jul 2019 11:24:44 -0400
Subject: [PATCH 10/24] arithmetic test

---
 tests/suite/config/asyncShare/arithmetic.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/suite/config/asyncShare/arithmetic.json b/tests/suite/config/asyncShare/arithmetic.json
index 01d76ccba..c1f8faf9c 100644
--- a/tests/suite/config/asyncShare/arithmetic.json
+++ b/tests/suite/config/asyncShare/arithmetic.json
@@ -1,5 +1,5 @@
 {
-  "tests": [ "+", "-", "*", "*bgw", "|", "^", "!", "abs", "/", "%" ],
+  "tests": [ "+", "-", "*", "*bgw", "|", "^", "!", "abs", "/", "%"],
   "suiteConf": {
     "port": 3001,
     "extensions": [ "asyncShare" ],

From 1fb0e3141c874f04ac78a3d04f0bce7e14a67192 Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Mon, 22 Jul 2019 01:46:38 -0400
Subject: [PATCH 11/24] bits tests

---
 demos/asyncshare/mpc.js                       |    7 +-
 lib/ext/jiff-client-asynchronousshare.js      | 1185 ++++-------------
 lib/ext/jiff-server-asyncshare.js             |   33 +
 lib/ext/temp.js                               |   54 -
 lib/jiff-client.js                            |   15 +-
 tests/suite/computations.js                   |    2 -
 tests/suite/config/asyncShare/arithmetic.json |   10 +-
 tests/suite/config/asyncShare/computations.js |    3 -
 .../asyncShare/constant arithmetic.json       |    2 +-
 tests/suite/config/asyncShare/generation.js   |   11 +
 tests/suite/config/bits/arithmetic.json       |   11 +-
 tests/suite/config/bits/computations.js       |   33 +-
 12 files changed, 317 insertions(+), 1049 deletions(-)
 delete mode 100644 lib/ext/temp.js

diff --git a/demos/asyncshare/mpc.js b/demos/asyncshare/mpc.js
index f9a665a74..c9b0422ce 100644
--- a/demos/asyncshare/mpc.js
+++ b/demos/asyncshare/mpc.js
@@ -32,9 +32,10 @@
     // The MPC implementation should go *HERE*
     var shares = jiff_instance.share(input);
     var sum = shares[1];
-    for (var i = 2; i <= jiff_instance.party_count; i++) {
-      sum = sum.smult(shares[i]);
-    }
+    //for (var i = 2; i <= jiff_instance.party_count; i++) {
+    //  sum = sum.smult(shares[i]);
+    //}
+    sum = sum.cdiv(2);
 
     // Return a promise to the final output(s)
     return jiff_instance.open(sum);
diff --git a/lib/ext/jiff-client-asynchronousshare.js b/lib/ext/jiff-client-asynchronousshare.js
index ee3bafe1a..26de6fb45 100644
--- a/lib/ext/jiff-client-asynchronousshare.js
+++ b/lib/ext/jiff-client-asynchronousshare.js
@@ -143,7 +143,12 @@
       return share.jiff.open(share, parties, op_ids);
     };
 
+    share.refresh = function (op_id) {
+      return share.isadd(share.jiff.server_generate_and_share({number: 0, ratios: share.ratios}, share.holders, share.threshold, share.Zp, op_id)[0]);
+    }
+
     share.add = function (o) {
+      console.log('correct adding share', share);
       if (share.isConstant(o)) {
         return share.cadd(o);
       }
@@ -164,65 +169,9 @@
       return share.smult(o, op_id);
     };
 
-    share.xor_bit = function (o) {
-      if (share.isConstant(o)) {
-        return share.cxor_bit(o);
-      }
-      return share.sxor_bit(o);
-    };
-
-    share.or_bit = function (o, op_id) {
+    share.div = function (o, op_id) {
       if (share.isConstant(o)) {
-        return share.cor_bit(o);
-      }
-      return share.sor_bit(o, op_id);
-    };
-
-    share.gteq = function (o) {
-      if (share.isConstant(o)) {
-        return share.cgteq(o);
-      }
-      return share.sgteq(o);
-    };
-
-    share.gt = function (o) {
-      if (share.isConstant(o)) {
-        return share.cgt(o);
-      }
-      return share.sgt(o);
-    };
-
-    share.lteq = function (o) {
-      if (share.isConstant(o)) {
-        return share.clteq(o);
-      }
-      return share.slteq(o);
-    };
-
-    share.lt = function (o) {
-      if (share.isConstant(o)) {
-        return share.clt(o);
-      }
-      return share.slt(o);
-    };
-
-    share.eq = function (o) {
-      if (share.isConstant(o)) {
-        return share.ceq(o);
-      }
-      return share.seq(o);
-    };
-
-    share.neq = function (o) {
-      if (share.isConstant(o)) {
-        return share.cneq(o);
-      }
-      return share.sneq(o);
-    };
-
-    share.div = function (o) {
-      if (share.isConstant(o)) {
-        return share.cdiv(o);
+        return share.cdiv(o, op_id);
       }
       return share.sdiv(o);
     };
@@ -251,7 +200,7 @@
         if (typeof(share.value) == 'number') {
           return (share.legacy.cadd(o)).promise;
         }
-        return ready_add(o);
+        return ready_add();
       }, share.error);
       return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp, null, share.ratios);
     };
@@ -491,813 +440,140 @@
     };
 
     share.cdiv = function (o, op_id) {
-      var result, divshare;
-
-      var ready_div = function () {
-        result = [];
-        var share_val = share.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          divshare = share.legacy.cdiv(o, op_id);
-          if (divshare.ready) {
-            result.push(divshare.value);
-          } else {
-            divshare.promise.then(function () {
-              result.push(divshare.value);
-            });
-          }
-        }
-        share.value = share_val;
-        return result;
-      };
-
-      if (share.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.cdiv(o, op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_div(), share.holders, share.threshold, share.Zp);
-        }
-      }
-
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          divshare = share.legacy.cdiv(o);
-          if (divshare.ready) {
-            return divshare.value;
-          }
-          result = divshare.promise.then(function () {
-            return divshare.value;
-          });
-          return result;
-        } else {
-          return ready_div();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };
-
-    share.cdivfac = function (o) {
-      var result, divshare;
-
-      var ready_divfac = function () {
-        result = [];
-        var share_val = share.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          divshare = share.legacy.cdivfac(o);
-          if (divshare.ready) {
-            result.push(divshare.value);
-          } else {
-            divshare.promise.then(function () {
-              result.push(divshare.value);
-            });
-          }
-        }
-        share.value = share_val;
-        return result;
-      };
-
-      if (share.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.cdivfac(o);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_divfac(), share.holders, share.threshold, share.Zp);
-        }
-      }
-
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          divshare = share.legacy.cdivfac(o);
-          if (divshare.ready) {
-            return divshare.value;
-          }
-          result = divshare.promise.then(function () {
-            return divshare.value;
-          });
-          return result;
-        } else {
-          return ready_divfac();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };
-
-    share.sdiv = function (o, l, op_id) {
-      var final_deferred = new Deferred();
-      var final_promise = final_deferred.promise;
-
-      var ready_div = function () {
-        var result = [];
-        var promises = [];
-
-        for (var i = 0; i < share.value.length; i++) {
-          var share_tmp = jiff.secret_share(share.jiff, true, null, share.value[i], share.holders, share.threshold, share.Zp, null, share.ratios);
-          var o_tmp = jiff.secret_share(o.jiff, true, null, o.value[i], o.holders, o.threshold, o.Zp, null, o.ratios);
-          var divshare = share_tmp.legacy.sdiv(o_tmp, l, op_id + ':' + i);
-          promises.push(divshare.promise);
-
-          divshare.promise.then((function (i, divshare) {
-            console.log('divshare', i, divshare.value);
-            result[i] = divshare.value;
-          }).bind(null, i, divshare));
-        }
-
-        Promise.all(promises).then(function () {
-          final_deferred.resolve(result);
-        });
-      };
-
-      if (share.ready && o.ready) {
-        ready_div();
-        return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
-      }
-
-      // promise to execute ready_add when both are ready
-      share.pick_promise(o).then( function () {
-        ready_div();
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
-    };
-
-    share.smod = function (o, l, op_id) {
-      var result, modshare;
-
-      var ready_mod = function () {
-        result = [];
-        var share_val = share.value;
-        var o_val = o.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          o.value = o_val[i];
-          modshare = share.legacy.smod(o, l, op_id);
-          if (modshare.ready) {
-            result.push(modshare.value);
-          } else {
-            modshare.promise.then(function () {
-              result.push(modshare.value);
-            });
-          }
-        }
-        share.value = share_val;
-        o.value = o_val;
-        return result;
-      };
-
-      if (share.ready && o.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.smod(o, l, op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_mod(), share.holders, max(share.threshold, o.threshold), share.Zp);
-        }
-      }
-
-      // promise to execute ready_add when both are ready
-      var promise = share.pick_promise(o).then( function () {
-        if (typeof (share.value) === 'number') {
-          modshare = share.legacy.smod(o, l, op_id);
-          if (modshare.ready) {
-            return modshare.value;
-          }
-          result = modshare.promise.then(function () {
-            return modshare.value;
-          });
-          return result;
-        } else {
-          return ready_mod();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
-    };
-
-    share.cxor_bit = function (o) {
-      var result, xor_share;
-      var ready_xor_bit = function () {
-        result = [];
-        var share_val = share.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          xor_share = share.legacy.cxor_bit(o);
-          if (xor_share.ready) {
-            result.push(xor_share.value);
-          } else {
-            xor_share.promise.then(function () {
-              result.push(xor_share.value);
-            });
-          }
-        }
-        share.value = share_val;
-        return result;
-      };
-
-      if (share.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.cxor_bit(o);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_xor_bit(), share.holders, share.threshold, share.Zp);
-        }
-      }
-
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          xor_share = share.legacy.cxor_bit(o);
-          if (xor_share.ready) {
-            return xor_share.value;
-          }
-          result = xor_share.promise.then(function () {
-            return xor_share.value;
-          });
-          return result;
-        } else {
-          return ready_xor_bit();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };
-
-
-    share.cor_bit = function (o) {
-      var result, or_share;
-      var ready_or_bit = function () {
-        result = [];
-        var share_val = share.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          or_share = share.legacy.cor_bit(o);
-          if (or_share.ready) {
-            result.push(or_share.value);
-          } else {
-            or_share.promise.then(function () {
-              result.push(or_share.value);
-            });
-          }
-        }
-        share.value = share_val;
-        return result;
-      };
-
-      if (share.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.cor_bit(o).value;
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_or_bit(), share.holders, share.threshold, share.Zp);
-        }
-      }
-
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          or_share = share.legacy.cor_bit(o);
-          if (or_share.ready) {
-            return or_share.value;
-          }
-          result = or_share.promise.then(function () {
-            return or_share.value;
-          });
-          return result;
-        } else {
-          return ready_or_bit();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };
-
-    share.clt = function (o, op_id) {
-      var result, lt_share;
-      var ready_lt = function () {
-        result = [];
-        var share_val = share.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          lt_share = share.legacy.clt(o, op_id);
-          if (lt_share.ready) {
-            result.push(lt_share.value);
-          } else {
-            lt_share.promise.then(function () {
-              result.push(lt_share.value);
-            });
-          }
-        }
-        share.value = share_val;
-        return result;
-      };
-
-      if (share.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.clt(o, op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_lt(), share.holders, share.threshold, share.Zp);
-        }
-      }
-
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          lt_share = share.legacy.clt(o);
-          if (lt_share.ready) {
-            return lt_share.value;
-          }
-          result = lt_share.promise.then(function () {
-            return lt_share.value;
-          });
-          return result;
-        } else {
-          return ready_lt();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };
-
-    share.clteq = function (o, op_id) {
-      var result, lteq_share;
-      var ready_lteq = function () {
-        result = [];
-        var share_val = share.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          lteq_share = share.legacy.clteq(o, op_id);
-          if (lteq_share.ready) {
-            result.push(lteq_share.value);
-          } else {
-            lteq_share.promise.then(function () {
-              result.push(lteq_share.value);
-            });
-          }
-        }
-        share.value = share_val;
-        return result;
-      };
-
-        if (share.ready) {
-          if (typeof (share.value) === 'number') {
-            return share.legacy.clteq(o, op_id);
-          } else {
-            return share.jiff.secret_share(share.jiff, true, null, ready_lteq(), share.holders, share.threshold, share.Zp);
-          }
-        }
-
-        var promise = share.promise.then( function () {
-          if (typeof (share.value) === 'number') {
-            lteq_share = share.legacy.clteq(o);
-            if (lteq_share.ready) {
-              return lteq_share.value;
-            }
-            result = lteq_share.promise.then(function () {
-              return lteq_share.value;
-            });
-            return result;
-          } else {
-            return ready_lteq();
-          }
-        }, share.error);
-        return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };
-
-    share.cgt = function (o, op_id) {
-      var result, gt_share;
-      var ready_gt = function () {
-        result = [];
-        var share_val = share.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          gt_share = share.legacy.cgt(o, op_id);
-          if (gt_share.ready) {
-            result.push(gt_share.value);
-          } else {
-            gt_share.promise.then(function () {
-              result.push(gt_share.value);
-            });
-          }
-        }
-        share.value = share_val;
-        return result;
-      };
-
-      if (share.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.cgt(o, op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_gt(), share.holders, share.threshold, share.Zp);
-        }
+      if (!(share.isConstant(o))) {
+        throw new Error('parameter should be a number (/)');
       }
 
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          gt_share = share.legacy.cgt(o, op_id);
-          if (gt_share.ready) {
-            return gt_share.value;
-          }
-          result = gt_share.promise.then(function () {
-            return gt_share.value;
-          });
-          return result;
-        } else {
-          return ready_gt();
-        }
-      }, share.error);
-        return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };
-
-    share.cgteq = function (o, op_id) {
-      var result, gteq_share;
-      var ready_gteq = function () {
-        result = [];
-        var share_val = share.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          gteq_share = share.legacy.cgteq(o, op_id);
-          if (gteq_share.ready) {
-            result.push(gteq_share.value);
-          } else {
-            gteq_share.promise.then(function () {
-              result.push(gteq_share.value);
-            });
-          }
-        }
-        share.value = share_val;
-        return result;
-      };
-
-      if (share.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.cgteq(o, op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_gteq(), share.holders, share.threshold, share.Zp);
-        }
+      if (share_helpers['<='](o, 0)) {
+        throw new Error('divisor must be > 0 (cst/): ' + o);
       }
 
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          gteq_share = share.legacy.cgteq(o, op_id);
-          if (gteq_share.ready) {
-            return gteq_share.value;
-          }
-          result = gteq_share.promise.then(function () {
-            return gteq_share.value;
-          });
-          return result;
-        } else {
-          return ready_gteq();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };
-
-    share.ceq = function (o, op_id) {
-      var result, eq_share;
-      var ready_eq = function () {
-        result = [];
-        var share_val = share.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          eq_share = share.legacy.ceq(o, op_id);
-          if (eq_share.ready) {
-            result.push(eq_share.value);
-          } else {
-            eq_share.promise.then(function () {
-              result.push(eq_share.value);
-            });
-          }
-        }
-        share.value = share_val;
-        return result;
-      };
-
-      if (share.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.ceq(o, op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_eq(), share.holders, share.threshold, share.Zp);
-        }
+      if (share_helpers['<='](share.Zp, o)) {
+        throw new Error('divisor must be < share.Zp (' + share.Zp + ') in (cst/): ' + o);
       }
 
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          eq_share = share.legacy.ceq(o, op_id);
-          if (eq_share.ready) {
-            return eq_share.value;
-          }
-          result = eq_share.promise.then(function () {
-            return eq_share.value;
-          });
-          return result;
-        } else {
-          return ready_eq();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };
-
-    share.cneq = function (o, op_id) {
-      var result, neq_share;
-      var ready_neq = function () {
-        result = [];
-        var share_val = share.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          neq_share = share.legacy.cneq(o, op_id);
-          if (neq_share.ready) {
-            result.push(neq_share.value);
-          } else {
-            neq_share.promise.then(function () {
-              result.push(neq_share.value);
-            });
-          }
-        }
-        share.value = share_val;
-        return result;
-      };
-
-      if (share.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.cneq(o, op_id).value;
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_neq(), share.holders, share.threshold, share.Zp);
-        }
+      if (op_id == null) {
+        op_id = share.jiff.counters.gen_op_id('c/', share.holders);
       }
 
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          neq_share = share.legacy.cneq(o, op_id);
-          if (neq_share.ready) {
-            return neq_share.value;
-          }
-          result = neq_share.promise.then(function () {
-            return neq_share.value;
-          });
-          return result;
-        } else {
-          return ready_neq();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };
-
-    share.slt = function (o, op_id) {
+      // Allocate share for result to which the answer will be resolved once available
       var final_deferred = new Deferred();
       var final_promise = final_deferred.promise;
+      var result = share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, share.threshold, share.Zp, 'share:' + op_id, share.ratios);
 
-      var ready_lt = function () {
-        var result = [];
-        var promises = [];
+      var ZpOVERc = share_helpers['floor/'](share.Zp, o);
 
-        for (var i = 0; i < share.value.length; i++) {
-          var share_tmp = jiff.secret_share(share.jiff, true, null, share.value[i], share.holders, share.threshold, share.Zp, null, share.ratios);
-          var o_tmp = jiff.secret_share(o.jiff, true, null, o.value[i], o.holders, o.threshold, o.Zp, null, o.ratios);
-          var lt_share = share_tmp.legacy.slt(o_tmp, op_id);
-          promises.push(lt_share.promise);
+      // add uniform noise to self so we can open
+      var nOVERc = share.jiff.server_generate_and_share({max: ZpOVERc, ratios: share.ratios}, share.holders, share.threshold, share.Zp, op_id + ':nOVERc')[0];
+      var nMODc = share.jiff.server_generate_and_share({max: o, ratios: share.ratios}, share.holders, share.threshold, share.Zp, op_id + ':nMODc')[0];
+      var noise = nOVERc.icmult(o).isadd(nMODc);
 
+      var noisyX = share.isadd(noise);
 
-          lt_share.promise.then((function (i, lt_share) {
-            result[i] = lt_share.value;
-          }).bind(null, i, lt_share));
-        }
-
-        Promise.all(promises).then(function () {
-          final_deferred.resolve(result);
-        });
-      };
-
-      if (share.ready && o.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.slt(o, op_id);
-        } else {
-          ready_lt()
-          return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
-        }
-      }
-
-      // promise to execute ready_add when both are ready
-      share.pick_promise(o).then( function () {
-        if (typeof (share.value) === 'number') {
-          lt_share = share.legacy.slt(o, op_id);
-          if (lt_share.ready) {
-            return lt_share.value;
-          }
-          result = lt_share.promise.then(function () {
-            return lt_share.value;
-          });
-          return result;
-        } else {
-          ready_lt();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
-    };
-
-    share.slteq = function (o, op_id) {
-      var result, lteq_share;
-
-      var ready_lteq = function () {
-        result = [];
-        var share_val = share.value;
-        var o_val = o.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          o.value = o_val[i];
-          lteq_share = share.legacy.slteq(o, op_id);
-          if (lteq_share.ready) {
-            result.push(lteq_share.value);
-          } else {
-            lteq_share.promise.then(function () {
-              result.push(lteq_share.value);
-            });
-          }
-        }
-        share.value = share_val;
-        o.value = o_val;
-        return result;
-      };
-
-      if (share.ready && o.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.slteq(o, op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_lteq(), share.holders, max(share.threshold, o.threshold), share.Zp);
-        }
-      }
-
-      // promise to execute ready_add when both are ready
-      var promise = share.pick_promise(o).then( function () {
-        if (typeof (share.value) === 'number') {
-          lteq_share = share.legacy.slteq(o, op_id);
-          if (lteq_share.ready) {
-            return lteq_share.value;
-          }
-          result = lteq_share.promise.then(function () {
-            return lteq_share.value;
-          });
-          return result;
-        } else {
-          return ready_lteq();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, finalpromise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
-    };
+      share.jiff.internal_open(noisyX, noisyX.holders, op_id + ':open').then(function (noisyX) {
+        var wrapped = share.icgt(noisyX, op_id + ':wrap_cgt'); // 1 => x + noise wrapped around Zp, 0 otherwise
 
-    share.sgt = function (o, op_id) {
-      var result, gt_share;
+        // if we did not wrap
+        var noWrapDiv = share_helpers['floor/'](noisyX, o);
+        var unCorrectedQuotient = nOVERc.icmult(-1).icadd(noWrapDiv).icsub(1);
+        var verify = share.issub(unCorrectedQuotient.icmult(o));
+        var isNotCorrect = verify.icgteq(o, op_id + ':cor1');
+        var noWrapAnswer = unCorrectedQuotient.isadd(isNotCorrect); // if incorrect => isNotCorrect = 1 => quotient = unCorrectedQuotient - 1
 
-      var ready_gt = function () {
-        var result = [];
-        var share_val = share.value;
-        var o_val = o.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          o.value = o_val[i];
-          gt_share = share.legacy.sgt(o, op_id);
-          if (gt_share.ready) {
-            result.push(gt_share.value);
-          } else {
-            gt_share.promise.then(function () {
-              result.push(gt_share.value);
-            });
-          }
-        }
-        share.value = share_val;
-        o.value = o_val;
-        return result;
-      };
+        // if we wrapped
+        var wrapDiv = share_helpers['floor/'](share_helpers['+'](noisyX, share.Zp), o);
+        var unCorrectedQuotient2 = nOVERc.icmult(-1).icadd(wrapDiv).icsub(1);
+        var verify2 = share.issub(unCorrectedQuotient2.icmult(o));
+        var isNotCorrect2 = verify2.icgteq(o, op_id + ':cor2');
+        var wrapAnswer = unCorrectedQuotient2.isadd(isNotCorrect2); // if incorrect => isNotCorrect = 1 => quotient = unCorrectedQuotient - 1
 
-      if (share.ready && o.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.sgt(o, op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_gt(), share.holders, max(share.threshold, o.threshold), share.Zp);
-        }
-      }
+        var answer = noWrapAnswer.isadd(wrapped.ismult(wrapAnswer.issub(noWrapAnswer), op_id + ':smult'));
+        answer.wThen(final_deferred.resolve);
+      });
 
-      // promise to execute ready_add when both are ready
-      var promise = share.pick_promise(o).then( function () {
-        if (typeof (share.value) === 'number') {
-          gt_share = share.legacy.sgt(o, op_id);
-          if (gt_share.ready) {
-            return gt_share.value;
-          }
-          result = gt_share.promise.then(function () {
-            return gt_share.value;
-          });
-          return result;
-        } else {
-          return ready_gt();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      // special case, if result is zero, sometimes we will get to -1 due to how correction happens above (.csub(1) and then compare)
+      var zeroIt = share.iclt(o, op_id + ':zero_check').inot();
+      return result.ismult(zeroIt, op_id + ':zero_it');
     };
 
-    share.sgteq = function (o, op_id) {
-      var result, gteq_share;
+    share.cdivfac = function (o) {
+      if (!(share.isConstant(o))) {
+        throw new Error('Parameter should be a number (cdivfac)');
+      }
+      var inv = share.jiff.helpers.extended_gcd(o, share.Zp)[0];
 
-      var ready_gteq = function () {
-        result = [];
-        var share_val = share.value;
-        var o_val = o.value;
+      var ready_cdivfac = function () {
+        var result = [];
         for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          o.value = o_val[i];
-          gteq_share = share.legacy.sgteq(o, op_id);
-          if (gteq_share.ready) {
-            result.push(gteq_share.value);
-          } else {
-            gteq_share.promise.then(function () {
-              result.push(gteq_share.value);
-            });
-          }
+          result.push(share.jiff.helpers.mod(share_helpers['*'](share.value[i], inv), share.Zp))
         }
-        share.value = share_val;
-        o.value = o_val;
         return result;
-      };
+      }
 
-      if (share.ready && o.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.sgteq(o, op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_gteq(), share.holders, max(share.threshold, o.threshold), share.Zp);
-        }
+      if (share.ready) {
+        // If share is ready.
+        return share.jiff.secret_share(share.jiff, true, null, ready_cdivfac(), share.holders, share.threshold, share.Zp, null, share.ratios);
       }
 
-      // promise to execute ready_add when both are ready
-      var promise = share.pick_promise(o).then( function () {
-        if (typeof (share.value) === 'number') {
-          gteq_share = share.legacy.sgteq(o, op_id);
-          if (gteq_share.ready) {
-            return gteq_share.value;
-          }
-          result = gteq_share.promise.then(function () {
-              return gteq_share.value;
-          });
-          return result;
-        } else {
-          return ready_gteq();
-        }
+      var promise = share.promise.then(function () {
+        return ready_cdivfac();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp, null, share.ratios);
     };
 
-    share.seq = function (o, op_id) {
-      var result, eq_share;
+    share.sdiv = function (o, l, op_id) {
+      var final_deferred = new Deferred();
+      var final_promise = final_deferred.promise;
+
+      var ready_div = function () {
+        var result = [];
+        var promises = [];
 
-      var ready_eq = function () {
-        result = [];
-        var share_val = share.value;
-        var o_val = o.value;
         for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          o.value = o_val[i];
-          eq_share = share.legacy.seq(o, op_id);
-          if (eq_share.ready) {
-            result.push(eq_share.value);
-          } else {
-            eq_share.promise.then(function () {
-              result.push(eq_share.value);
-            });
-          }
+          var share_tmp = jiff.secret_share(share.jiff, true, null, share.value[i], share.holders, share.threshold, share.Zp, null, share.ratios);
+          var o_tmp = jiff.secret_share(o.jiff, true, null, o.value[i], o.holders, o.threshold, o.Zp, null, o.ratios);
+          var divshare = share_tmp.legacy.sdiv(o_tmp, l, op_id + ':' + i);
+          promises.push(divshare.promise);
+
+          divshare.promise.then((function (i, divshare) {
+            console.log('divshare', i, divshare.value);
+            result[i] = divshare.value;
+          }).bind(null, i, divshare));
         }
-        share.value = share_val;
-        o.value = o_val;
-        return result;
+
+        Promise.all(promises).then(function () {
+          final_deferred.resolve(result);
+        });
       };
 
       if (share.ready && o.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.seq(o, op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_eq(), share.holders, max(share.threshold, o.threshold), share.Zp);
-        }
+        ready_div();
+        return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
       }
 
       // promise to execute ready_add when both are ready
-      var promise = share.pick_promise(o).then( function () {
-        if (typeof (share.value) === 'number') {
-          eq_share = share.legacy.seq(o, op_id);
-          if (eq_share.ready) {
-            return eq_share.value;
-          }
-          result = eq_share.promise.then(function () {
-            return eq_share.value;
-          });
-          return result;
-        } else {
-          return ready_eq();
-        }
+      share.pick_promise(o).then( function () {
+        ready_div();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
-    share.sneq = function (o, op_id) {
-      var result, neq_share;
+    share.smod = function (o, l, op_id) {
+      var result, modshare;
 
-      var ready_neq = function () {
+      var ready_mod = function () {
         result = [];
         var share_val = share.value;
         var o_val = o.value;
         for (var i = 0; i < share.value.length; i++) {
           share.value = share_val[i];
           o.value = o_val[i];
-          neq_share = share.legacy.sneq(o, op_id);
-          if (neq_share.ready) {
-            result.push(neq_share.value);
+          modshare = share.legacy.smod(o, l, op_id);
+          if (modshare.ready) {
+            result.push(modshare.value);
           } else {
-            neq_share.promise.then(function () {
-              result.push(neq_share.value);
+            modshare.promise.then(function () {
+              result.push(modshare.value);
             });
           }
         }
@@ -1308,165 +584,86 @@
 
       if (share.ready && o.ready) {
         if (typeof (share.value) === 'number') {
-          return share.legacy.sneq(o, op_id);
+          return share.legacy.smod(o, l, op_id);
         } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_neq(), share.holders, max(share.threshold, o.threshold), share.Zp);
+          return share.jiff.secret_share(share.jiff, true, null, ready_mod(), share.holders, max(share.threshold, o.threshold), share.Zp);
         }
       }
 
       // promise to execute ready_add when both are ready
       var promise = share.pick_promise(o).then( function () {
         if (typeof (share.value) === 'number') {
-          neq_share = share.legacy.sneq(o, op_id);
-          if (neq_share.ready) {
-            return neq_share.value;
+          modshare = share.legacy.smod(o, l, op_id);
+          if (modshare.ready) {
+            return modshare.value;
           }
-          result = neq_share.promise.then(function () {
-            return neq_share.value;
+          result = modshare.promise.then(function () {
+            return modshare.value;
           });
           return result;
         } else {
-          return ready_neq();
+          return ready_mod();
         }
       }, share.error);
       return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
     };
 
-    /*share.lt_halfprime = function (op_id) {
-      var result, halfprime_share;
-
-      var ready_lt_halfprime = function () {
-        result = [];
-        var share_val = share.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          halfprime_share = share.legacy.lt_halfprime(op_id);
-          if (halfprime_share.ready) {
-            result.push(halfprime_share.value);
-          } else {
-            halfprime_share.promise.then(function () {
-              result.push(halfprime_share.value);
-            });
-          }
-        }
-        share.value = share_val;
-        return result;
-      };
-
-      if (share.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.lt_halfprime(op_id);
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_lt_halfprime(), share.holders, share.threshold, share.Zp);
-        }
+    share.lt_halfprime = function (op_id) {
+      if (op_id == null) {
+        op_id = share.jiff.counters.gen_op_id('lt_hp', share.holders);
       }
 
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          halfprime_share = share.legacy.lt_halfprime(op_id);
-          if (halfprime_share.ready) {
-            return halfprime_share.value;
-          }
-          result = halfprime_share.promise.then(function () {
-            return halfprime_share.value;
-          });
-          return result;
-        } else {
-          return ready_lt_halfprime();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };*/
-
-    /*share.not = function () {
-      var result, not_share;
-      var ready_not = function () {
-        result = [];
-        var share_val = share.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          not_share = share.legacy.not();
-          if (not_share.ready) {
-            result.push(not_share.value);
-          } else {
-            not_share.promise.then(function () {
-              result.push(not_share.value);
-            });
-          }
-        }
-        share.value = share_val;
-        return result;
-      };
-
-      if (share.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.not();
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_not(), share.holders, share.threshold, share.Zp);
-        }
-      }
+      var final_deferred = new Deferred();
+      var final_promise = final_deferred.promise;
+      var result = share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, share.threshold, share.Zp, 'share:' + op_id, share.ratios);
+
+      // if 2*self is even, then self is less than half prime, otherwise self is greater or equal to half prime
+      var share2 = share.icmult(2);
+
+      // To check if share is even, we will use pre-shared bits as some form of a bit mask
+      var bitLength = share_helpers['floor'](share.jiff.helpers.bLog(share2.Zp, 2)); // TODO: this leaks one bit, fix it for mod 2^n
+      var bits = share.jiff.server_generate_and_share({
+        bit: true,
+        count: bitLength,
+        ratios: share.ratios
+      }, share2.holders, share2.threshold, share2.Zp, op_id + ':number:bits');
+      bits[bitLength] = share.jiff.server_generate_and_share({number: 0, ratios: share.ratios}, share2.holders, share2.threshold, share2.Zp, op_id + ':number:' + bitLength)[0]; // remove this line when fixing TODO
+
+      // bit composition: r = (rl ... r1 r0)_10
+      var r = share.jiff.protocols.bits.bit_composition(bits);
+
+      // open share + noise, and utilize opened value with shared bit representation of noise to check the least significant digit of share.
+      share2.jiff.internal_open(r.isadd(share2), share2.holders, op_id + ':open').then(function (result) {
+        var wrapped = share.jiff.protocols.bits.cgt(bits, result, op_id + ':bits.cgt');
+        wrapped.ratios = share.ratios;
+        var isOdd = share.jiff.helpers.mod(result, 2);
+        isOdd = bits[0].icxor_bit(isOdd);
+        isOdd = isOdd.isxor_bit(wrapped, op_id + ':sxor_bit');
+
+        var answer = isOdd.inot();
+        answer.wThen(final_deferred.resolve);
+      });
 
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          not_share = share.legacy.not();
-          if (not_share.ready) {
-            return not_share.value;
-          }
-          result = not_share.promise.then(function () {
-            return not_share.value;
-          });
-          return result;
-        } else {
-          return ready_not();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };*/
+      return result;
+    };
 
-    share.if_else = function (trueVal, falseVal, op_id) {
-      var result, ifelseshare;
-      var ready_if_else = function () {
-        result = [];
-        var share_val = share.value;
-        for (var i = 0; i < share.value.length; i++) {
-          share.value = share_val[i];
-          ifelseshare = share.legacy.if_else(trueVal, falseVal, op_id);
-          if (ifelseshare.ready) {
-            result.push(ifelseshare.value);
-          } else {
-            ifelseshare.promise.then(function () {
-              result.push(ifelseshare.value);
-            });
-          }
-        }
-        share.value = share_val;
-        return result;
-      };
+    share.clt = function (o, op_id) {
+      var result = share.legacy.clt(o, op_id);
+      result.ratios = share.ratios;
+      return result;
+    }
 
-      if (share.ready) {
-        if (typeof (share.value) === 'number') {
-          return share.legacy.if_else(trueVal, falseVal, op_id).value;
-        } else {
-          return share.jiff.secret_share(share.jiff, true, null, ready_if_else(), share.holders, share.threshold, share.Zp);
-        }
-      }
+    share.slt = function (o, op_id) {
+      var result = share.legacy.slt(o, op_id);
+      result.ratios = share.ratios;
+      return result;
+    }
 
-      var promise = share.promise.then( function () {
-        if (typeof (share.value) === 'number') {
-          ifelseshare = share.legacy.if_else(trueVal, falseVal, op_id);
-          if (ifelseshare.ready) {
-            return ifelseshare.value;
-          }
-          result = ifelseshare.promise.then(function () {
-            return ifelseshare.value;
-          });
-          return result;
-        } else {
-          return ready_if_else();
-        }
-      }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp);
-    };
+    share.cgt = function (o, op_id) {
+      var result = share.legacy.cgt(o, op_id);
+      result.ratios = share.ratios;
+      return result;
+    }
 
     share.isadd = share.sadd;
     share.issub = share.ssub;
@@ -1474,6 +671,10 @@
     share.icadd = share.cadd;
     share.icsub = share.csub;
     share.icmult = share.cmult;
+    share.ilt_halfprime = share.lt_halfprime;
+    share.islt = share.slt;
+    share.iclt = share.clt;
+    share.icgt = share.cgt;
 
     return share;
   }
@@ -1604,7 +805,7 @@
 
         // refresh/reshare, so that the original share remains secret, instead
         // a new share is sent/open without changing the actual value.
-        //share = share.refresh('refresh:' + op_ids[parties[0]]);
+        share = share.refresh('refresh:' + op_ids[parties[0]]);
 
         // The given share has been computed, share it to all parties
         if (share.ready) {
@@ -1681,7 +882,7 @@
       return jiff_open(jiff, share, parties, op_ids);
     };
 
-    jiff.share = function (secret, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios) {
+    jiff_share = function (jiff, secret, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios) {
       var i, j, p_id, p_ratio;
 
       // defaults
@@ -1793,6 +994,25 @@
       return result;
     };
 
+    jiff.share = function (secret, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios) {
+      // type check to confirm the secret to be shared is a number
+      // for fixed-point extension it should allow non-ints
+      if (secret != null && (typeof(secret) !== 'number' || Math.floor(secret) !== secret || secret < 0)) {
+        throw new Error('secret must be a non-negative whole number');
+      }
+      if (secret != null && (secret >= (Zp == null ? jiff.Zp : Zp))) {
+        throw new Error('secret must fit inside Zp');
+      }
+      return jiff.internal_share(secret, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios);
+    };
+
+    /**
+     * Same as jiff-instance.share, but used by internal JIFF primitives/protocols (bgw).
+     */
+    jiff.internal_share = function (secret, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios) {
+      return jiff_share(jiff, secret, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios);
+    };
+
 
     function jiff_triplet(jiff, receivers_list, threshold, Zp, triplet_id, receivers_ratios) {
       if (Zp == null) {
@@ -1843,6 +1063,61 @@
       return jiff_triplet(jiff, receivers_list, threshold, Zp, triplet_id, receivers_ratios);
     };
 
+    jiff_server_share_number = function (jiff, options, receivers_list, threshold, Zp, number_id) {
+      if (Zp == null) {
+        Zp = jiff.Zp;
+      }
+      if (receivers_list == null) {
+        receivers_list = [];
+        for (var i = 1; i <= jiff.party_count; i++) {
+          receivers_list.push(i);
+        }
+      }
+      if (threshold == null) {
+        threshold = receivers_list.length;
+      }
+
+      // Get the id of the number.
+      if (number_id == null) {
+        number_id = jiff.counters.gen_number_id(receivers_list);
+      }
+
+      if (options == null) {
+        options = {};
+      }
+      if (options.count == null) {
+        options.count = 1;
+      }
+
+      var msg = {number_id: number_id, receivers: receivers_list, threshold: threshold, Zp: Zp, ratios: options.ratios};
+      msg = Object.assign(msg, options);
+
+      msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'number', msg], 2);
+      msg = JSON.stringify(msg);
+
+      // Setup deferreds to handle receiving the triplets later.
+      var shares = [];
+      for (i = 0; i < options.count; i++) {
+        var deferred = new Deferred();
+        jiff.deferreds[number_id + ':' + i] = deferred;
+        shares[i] = jiff.secret_share(jiff, false, deferred.promise, undefined, receivers_list, threshold, Zp, number_id + ':' + i, options.ratios);
+      }
+
+      // Send a request to the server.
+      if (jiff.id === 's1') {
+        jiff.socket.safe_emit('number', msg);
+      } else {
+        var cipher = jiff.hooks.encryptSign(jiff, msg, jiff.keymap['s1'], jiff.secret_key);
+        jiff.socket.safe_emit('number', JSON.stringify(cipher));
+      }
+
+      return shares;
+    }
+
+    jiff.server_generate_and_share = function (options, receivers_list, threshold, Zp, number_id) {
+      return jiff_server_share_number(jiff, options, receivers_list, threshold, Zp, number_id);
+    };
+
 
     /* HOOKS */
     jiff.hooks.createSecretShare.push(createMultipleSharesSecretShare);
diff --git a/lib/ext/jiff-server-asyncshare.js b/lib/ext/jiff-server-asyncshare.js
index d91e15f03..024dff9f3 100644
--- a/lib/ext/jiff-server-asyncshare.js
+++ b/lib/ext/jiff-server-asyncshare.js
@@ -93,6 +93,39 @@ exports.make_jiff = function (base_instance, options) {
     return {triplet: all_triplets[triplet_id][from_id], triplet_id: triplet_id};
   };
 
+  jiff.request_number_share = function (msg, computation_id, from_id) {
+    // parse message/request
+    var base_number_id = msg.number_id;
+    var receivers = msg.receivers;
+    var threshold = msg.threshold;
+    var Zp = msg.Zp;
+    var count = msg.count;
+    var ratios = msg.ratios;
+
+    if (count == null) {
+      count = 1;
+    }
+
+    jiff.hooks.log(jiff, 'number ' + base_number_id + ' from ' + computation_id + '-' + from_id + ':: ' + JSON.stringify(msg));
+
+    if (jiff.numbers_map[computation_id] == null) {
+      jiff.numbers_map[computation_id] = {};
+    }
+
+    var result = [];
+    var all_numbers = jiff.numbers_map[computation_id];
+    for (var i = 0; i < count; i++) {
+      var number_id = base_number_id + ':' + i;
+      if (all_numbers[number_id] == null) { // Generate shares for number.
+        var number = jiff.hooks.generateNumber(jiff, computation_id, msg);
+        all_numbers[number_id] = jiff.hooks.computeShares(jiff, number, receivers, threshold, Zp, ratios);
+      }
+      result.push({number_id: number_id, number: all_numbers[number_id][from_id]});
+    }
+
+    return result;
+  };
+
   return jiff;
 };
 
diff --git a/lib/ext/temp.js b/lib/ext/temp.js
deleted file mode 100644
index 1affcc00c..000000000
--- a/lib/ext/temp.js
+++ /dev/null
@@ -1,54 +0,0 @@
-share.smult = function (o, op_id) {
-  var final_deferred = new Deferred();
-  var final_promise = final_deferred.promise;
-
-  var ready_mult = function () {
-    var result = [];
-    var promises = [];
-    for (var i = 0; i < share.value.length; i++) {
-      var share_tmp = jiff.secret_share(share.jiff, true, null, share.value[i], share.holders, share.threshold, share.Zp);
-      var o_tmp = jiff.secret_share(o.jiff, true, null, o.value[i], o.holders, o.threshold, o.Zp);
-      var multshare = share_tmp.legacy.smult(o_tmp, op_id + ':' + i);
-      promises.push(multshare.promise);
-
-      //var cb = function (i, multshare) {
-      //  result[i] = multshare.value;
-      //};
-      //multshare.promise.then(cb.bind(null, i, multshare));
-
-      multshare.promise.then((function (i, multshare){
-        result[i] = multshare.value;
-      }).bind(null, i, multshare));
-    }
-
-    Promise.all(promises).then(function () {
-      console.log(result);
-      final_deferred.resolve(result);
-    }, share.error);
-  };
-
-  if (share.ready && o.ready) {
-    if (typeof (share.value) === 'number') {
-      var res = share.legacy.smult(o, op_id);
-      res.promise.then(function () {
-        final_deferred.resolve(res.value);
-      });
-    } else {
-      ready_mult();
-    }
-  }
-
-  // promise to execute ready_add when both are ready
-  share.pick_promise(o).then(function () {
-    if (typeof (share.value) === 'number') {
-      var res = share.legacy.smult(o, op_id);
-      res.promise.then(function () {
-        final_deferred.resolve(res.value);
-      });
-    } else {
-      ready_mult();
-    }
-  }, share.error);
-
-  return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
-};
\ No newline at end of file
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index af1795fa3..2aa5565c2 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -1611,7 +1611,7 @@
      * @instance
      */
     self.refresh = function (op_id) {
-      return self;//self.isadd(self.jiff.server_generate_and_share({number: 0}, self.holders, self.threshold, self.Zp, op_id)[0]);
+      return self.isadd(self.jiff.server_generate_and_share({number: 0}, self.holders, self.threshold, self.Zp, op_id)[0]);
     };
 
     /**
@@ -2835,6 +2835,7 @@
 
       // bit composition: r = (rl ... r1 r0)_10
       var r = self.jiff.protocols.bits.bit_composition(bits);
+
       // open share + noise, and utilize opened value with shared bit representation of noise to check the least significant digit of share.
       share.jiff.internal_open(r.isadd(share), share.holders, op_id + ':open').then(function (result) {
         var wrapped = self.jiff.protocols.bits.cgt(bits, result, op_id + ':bits.cgt');
@@ -2876,7 +2877,7 @@
       // generate the bits of a random number less than our prime
       var bits = self.jiff.protocols.bits.rejection_sampling(0, self.Zp, self.threshold, self.holders, self.Zp, op_id + ':sampling');
       var r = self.jiff.protocols.bits.bit_composition(bits);
-
+      console.log('r', r);
       // add and reveal random number to self
       self.jiff.internal_open(r.isadd(self), self.holders, op_id + ':open').then(function (result) {
         // compute bits assuming r+self < Zp
@@ -4376,7 +4377,7 @@
      * @returns {SecretShare[]} an array of secret shares of shares of zeros / random bits / random numbers / random non-zero numbers according to options.
      */
     jiff.server_generate_and_share = function (options, receivers_list, threshold, Zp, number_id) {
-      return jiff_server_share_number(jiff, options, receivers_list, threshold, Zp, number_id)
+      return jiff_server_share_number(jiff, options, receivers_list, threshold, Zp, number_id);
     };
 
     /**
@@ -4556,16 +4557,12 @@
      * @returns {SecretShare} a secret share of the number represented by bits.
      */
     jiff.protocols.bits.bit_composition = function (bits) {
-      //console.log('bits', bits);
       var result = bits[0];
       var pow = 1;
       for (var i = 1; i < bits.length; i++) {
         pow = pow * 2;
         result = result.isadd(bits[i].icmult(pow));
       }
-      //result.promise.then(function () {
-      //  console.log('result', result.value);
-      //})
       return result;
     };
 
@@ -4588,7 +4585,7 @@
      *          where the key is the party id (from 1 to n)
      *          and the value is an array of secret shared bits.
      */
-    jiff.protocols.bits.share_bits = function (secret, bit_length, threshold, receivers_list, senders_list, Zp, share_id) {
+    jiff.protocols.bits.share_bits = function (secret, bit_length, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios) {
       var i;
       if (Zp == null) {
         Zp = jiff.Zp;
@@ -4626,7 +4623,7 @@
       }
 
       for (i = 0; i < bit_length; i++) {
-        var round = jiff.internal_share(local_bits[i], threshold, receivers_list, senders_list, Zp, share_id + ':' + i);
+        var round = jiff.internal_share(local_bits[i], threshold, receivers_list, senders_list, Zp, share_id + ':' + i, receivers_ratios);
         for (var si = 0; si < senders_list.length; si++) {
           var pid = senders_list[si];
           shared_bits[pid].push(round[pid]);
diff --git a/tests/suite/computations.js b/tests/suite/computations.js
index 3722be4d6..dfe438a56 100644
--- a/tests/suite/computations.js
+++ b/tests/suite/computations.js
@@ -191,11 +191,9 @@ exports.singleCompute = function (jiff_instance, shareParameters, test, values,
 
     // Compute
     var result = func(values[indices[0]], values[indices[1]]);
-
     //for (var i = 2; i < indices.length; i++) {
     //  result = func(result, values[indices[i]]);
     //}
-
     return result;
   } catch (err) {
     console.log(err);
diff --git a/tests/suite/config/asyncShare/arithmetic.json b/tests/suite/config/asyncShare/arithmetic.json
index fa884d55b..ffbd5b3cf 100644
--- a/tests/suite/config/asyncShare/arithmetic.json
+++ b/tests/suite/config/asyncShare/arithmetic.json
@@ -1,9 +1,5 @@
 {
-<<<<<<< HEAD
-  "tests": [ "+", "-", "*", "*bgw", "|", "^", "!", "abs", "/", "%"],
-=======
-  "tests": [ "*" ],
->>>>>>> asyncSharetests
+  "tests": [ "+", "-", "*", "*bgw", "|", "^", "!", "/", "%"],
   "suiteConf": {
     "port": 3001,
     "extensions": [ "asyncShare" ],
@@ -19,7 +15,7 @@
 
   "testConf": {
     "default": {
-      "count": 10,
+      "count": 1,
       "parallel": 25,
       "options": {
         "Zp": 15485867,
@@ -43,7 +39,7 @@
       }
     },
     "%": {
-      "count": 8,
+      "count": 1,
       "parallel": 3,
       "options": {
         "Zp": 127,
diff --git a/tests/suite/config/asyncShare/computations.js b/tests/suite/config/asyncShare/computations.js
index 3f2ba7590..ea15a480d 100644
--- a/tests/suite/config/asyncShare/computations.js
+++ b/tests/suite/config/asyncShare/computations.js
@@ -1,6 +1,3 @@
-// Acquire Zp from the jiff instance
-var Zp;
-
 // Flags success/failure
 var errors = [];
 var successes = [];
diff --git a/tests/suite/config/asyncShare/constant arithmetic.json b/tests/suite/config/asyncShare/constant arithmetic.json
index b02ba006b..f35d2a24a 100644
--- a/tests/suite/config/asyncShare/constant arithmetic.json	
+++ b/tests/suite/config/asyncShare/constant arithmetic.json	
@@ -15,7 +15,7 @@
 
   "testConf": {
     "default": {
-      "count": 1,
+      "count": 100,
       "parallel": 50,
       "options": {
         "Zp": 15485867,
diff --git a/tests/suite/config/asyncShare/generation.js b/tests/suite/config/asyncShare/generation.js
index d8c671ae0..eb96ab880 100644
--- a/tests/suite/config/asyncShare/generation.js
+++ b/tests/suite/config/asyncShare/generation.js
@@ -49,6 +49,17 @@ baseGeneration.generateComparisonInputs = function (test, count, options) {
   return inputs;
 }
 
+var oldConstantComparisonInputs = baseGeneration.generateConstantComparisonInputs;
+baseGeneration.generateConstantComparisonInputs = function (test, count, options) {
+  var inputs = [];
+  var arithInputs = oldConstantComparisonInputs(test, count, options);
+  var ratioInputs = baseGeneration.generateShareRatios(test,count,options);
+  for (var t = 0; t < count; t++) {
+    inputs.push([arithInputs[t], ratioInputs[t]]);
+  }
+  return inputs;
+}
+
 
 baseGeneration.generateShareInputs = function (test, count, options) {
   var all_parties = [];
diff --git a/tests/suite/config/bits/arithmetic.json b/tests/suite/config/bits/arithmetic.json
index 5cbacd4b8..1c24014c9 100644
--- a/tests/suite/config/bits/arithmetic.json
+++ b/tests/suite/config/bits/arithmetic.json
@@ -1,7 +1,8 @@
 {
-  "tests": [ "+", "-", "*", "/", "%" ],
+  "tests": [ "+" ],
   "suiteConf": {
     "port": 3001,
+    "extensions": [ "asyncShare" ],
     "generation": {
       "file": "config/bits/generation.js",
       "function": "generateArithmeticInputs"
@@ -16,7 +17,7 @@
     "default": {
       "share": "share_bits",
       "open": "open_bits",
-      "count": 10,
+      "count": 1,
       "parallel": 3,
       "options": {
         "Zp": 127,
@@ -27,7 +28,7 @@
     "*": {
       "share": "share_bits",
       "open": "open_bits",
-      "count": 10,
+      "count": 1,
       "parallel": 3,
       "options": {
         "Zp": 127,
@@ -38,7 +39,7 @@
     "/": {
       "share": "share_bits",
       "open": "composition",
-      "count": 10,
+      "count": 1,
       "parallel": 3,
       "options": {
         "Zp": 127,
@@ -48,7 +49,7 @@
     "%": {
       "share": "decomposition",
       "open": "composition",
-      "count": 10,
+      "count": 1,
       "parallel": 3,
       "options": {
         "Zp": 127,
diff --git a/tests/suite/config/bits/computations.js b/tests/suite/config/bits/computations.js
index 879849009..d8daa7f98 100644
--- a/tests/suite/config/bits/computations.js
+++ b/tests/suite/config/bits/computations.js
@@ -1,8 +1,3 @@
-
-// Flags success/failure
-var errors = [];
-var successes = [];
-
 // Use base computation but override interpreters.
 var baseComputations = require('../../computations.js');
 
@@ -163,11 +158,28 @@ baseComputations.shareHook = async function (jiff_instance, test, testInputs, in
   if (testConfig['share'] === 'share_bits') {
     var bitLength = testConfig['options']['max'] || jiff_instance.Zp;
     bitLength = bitLength.toString(2).length;
-    shares = jiff_instance.protocols.bits.share_bits(input, bitLength, threshold, receivers, senders);
+    shares = jiff_instance.protocols.bits.share_bits(input, bitLength, threshold, receivers, senders, jiff_instance.Zp, null, ratios);
   }
   return shares;
 };
 
+baseComputations.shareParameters = function (jiff_instance, test, testInputs) {
+  var input = testInputs[jiff_instance.id];
+
+  // Figure out who is sharing
+  var senders = [];
+  for (var p in testInputs) {
+    if (testInputs.hasOwnProperty(p) && p != 'constant') {
+      senders.push(/^\d+$/.test(p.toString()) ? parseInt(p) : p);
+    }
+  }
+  senders.sort();
+
+  // Figure out threshold
+  var threshold = test === '*bgw' ? Math.floor(jiff_instance.party_count / 2) : jiff_instance.party_count;
+  return {input: input, threshold: threshold, senders: senders, receivers: null, constant: testInputs['constant']};
+};
+
 // Opening bits
 baseComputations.openHook = async function (jiff_instance, test, share) {
   if (share === true || share === false) {
@@ -212,13 +224,14 @@ baseComputations.singleTest = async function (jiff_instance, test, testInputs) {
     shares['constant'] = shareParameters.constant;
 
     // Compute in the Open
-    var actualResult = await baseComputations.singleCompute(jiff_instance, shareParameters, test, testInputs[0], baseComputations.openInterpreter);
-
+    //var actualResult = await baseComputations.singleCompute(jiff_instance, shareParameters, test, testInputs, baseComputations.openInterpreter);
+    //console.log(actualResult);
     // Compute under MPC
     var mpcResult = await baseComputations.singleCompute(jiff_instance, shareParameters, test, shares, baseComputations.mpcInterpreter);
     if (mpcResult == null) {
       return null;
     }
+    //console.log(jiff_instance.id, 'mpc', mpcResult.length);
 
     // Open
     mpcResult = await baseComputations.openHook(jiff_instance, test, mpcResult);
@@ -226,11 +239,11 @@ baseComputations.singleTest = async function (jiff_instance, test, testInputs) {
     // Verify result
     // Assert both results are equal
     if (!baseComputations.verifyResultHook(test, mpcResult, actualResult)) {
-      errors.push(baseComputations.errorMessage(jiff_instance, test, testInputs[0], shareParameters, mpcResult, actualResult));
+      errors.push(baseComputations.errorMessage(jiff_instance, test, testInputs, shareParameters, mpcResult, actualResult));
       return false;
     }
 
-    successes.push(baseComputations.successMessage(jiff_instance, test, testInputs[0], shareParameters, mpcResult, actualResult));
+    successes.push(baseComputations.successMessage(jiff_instance, test, testInputs, shareParameters, mpcResult, actualResult));
   } catch (err) {
     console.log(err);
     errors.push(err);

From b9c409392b5481bd08905b664679711ccc6a7093 Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Mon, 22 Jul 2019 15:49:17 -0400
Subject: [PATCH 12/24] bits arithmetic

---
 demos/asyncshare/mpc.js                  | 18 +++++++++++-------
 lib/ext/jiff-client-asynchronousshare.js |  2 +-
 lib/jiff-client.js                       |  7 ++-----
 lib/jiff-server.js                       |  1 +
 tests/suite/computations.js              |  3 +--
 tests/suite/config/bits/computations.js  |  3 +--
 tests/suite/server.js                    |  8 +++-----
 7 files changed, 20 insertions(+), 22 deletions(-)

diff --git a/demos/asyncshare/mpc.js b/demos/asyncshare/mpc.js
index c9b0422ce..1a257be6f 100644
--- a/demos/asyncshare/mpc.js
+++ b/demos/asyncshare/mpc.js
@@ -24,20 +24,24 @@
   /**
    * The MPC computation
    */
-  exports.compute = function (input, jiff_instance) {
+  exports.compute = async function (input, jiff_instance) {
     if (jiff_instance == null) {
       jiff_instance = saved_instance;
     }
 
     // The MPC implementation should go *HERE*
-    var shares = jiff_instance.share(input);
+    var bitLength = 9;
+    var shares = jiff_instance.protocols.bits.share_bits(input, bitLength, null, null, null, null, null, {1: 2, 2: 2, 3: 1});
     var sum = shares[1];
-    //for (var i = 2; i <= jiff_instance.party_count; i++) {
-    //  sum = sum.smult(shares[i]);
-    //}
-    sum = sum.cdiv(2);
+    for (var i = 2; i <= jiff_instance.party_count; i++) {
+      sum = sum[0].jiff.protocols.bits.sadd(sum, shares[i]);
+    }
+
+
+
 
     // Return a promise to the final output(s)
-    return jiff_instance.open(sum);
+    var opensum = sum[0].jiff.protocols.bits.bit_composition(sum);
+    return opensum.open();
   };
 }((typeof exports === 'undefined' ? this.mpc = {} : exports), typeof exports !== 'undefined'));
diff --git a/lib/ext/jiff-client-asynchronousshare.js b/lib/ext/jiff-client-asynchronousshare.js
index 26de6fb45..08a29fdfd 100644
--- a/lib/ext/jiff-client-asynchronousshare.js
+++ b/lib/ext/jiff-client-asynchronousshare.js
@@ -361,7 +361,7 @@
       var a = triplet[0];
       var b = triplet[1];
       var c = triplet[2];
-
+      
       // d = s - a. e = o - b.
       var d = share.isadd(a.icmult(-1));
       var e = o.isadd(b.icmult(-1));
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index e53c9a6ce..eac9d5a70 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -2256,7 +2256,6 @@
       if (!self.jiff.helpers.array_equals(self.holders, o.holders)) {
         throw new Error('shares must be held by the same parties (^)');
       }
-
       return self.isadd(o).issub(self.ismult(o, op_id).icmult(2));
     };
 
@@ -2877,7 +2876,7 @@
       // generate the bits of a random number less than our prime
       var bits = self.jiff.protocols.bits.rejection_sampling(0, self.Zp, self.threshold, self.holders, self.Zp, op_id + ':sampling');
       var r = self.jiff.protocols.bits.bit_composition(bits);
-      console.log('r', r);
+     
       // add and reveal random number to self
       self.jiff.internal_open(r.isadd(self), self.holders, op_id + ':open').then(function (result) {
         // compute bits assuming r+self < Zp
@@ -4629,7 +4628,6 @@
           shared_bits[pid].push(round[pid]);
         }
       }
-
       return shared_bits;
     };
 
@@ -5241,10 +5239,9 @@
       bits1 = tmp; // longest array
 
       // initialize results
-      var result = many_secret_shares(jiff, bits1.length, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id);
+      var result = many_secret_shares(jiff, bits1.length, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id, bits1[0].ratios);
       var deferreds = result.deferreds;
       result = result.shares;
-
       var sum = bits1[0].isxor_bit(bits2[0], op_id + ':sxor_bit:initial');
       var carry = bits1[0].ismult(bits2[0], op_id + ':smult:initial');
 
diff --git a/lib/jiff-server.js b/lib/jiff-server.js
index c302f0714..030ad2493 100644
--- a/lib/jiff-server.js
+++ b/lib/jiff-server.js
@@ -36,6 +36,7 @@ function secureRandom(max) {
     }
   }
 }
+
 function mod(x, y) {
   if (x < 0) {
     return (x % y) + y;
diff --git a/tests/suite/computations.js b/tests/suite/computations.js
index 3bfe407ea..023e54704 100644
--- a/tests/suite/computations.js
+++ b/tests/suite/computations.js
@@ -44,8 +44,7 @@ exports.mod = function (x, y) {
 // How to interpret MPC operations
 exports.mpcInterpreter = {
   '+': function (operand1, operand2) {
-    var result = operand1.add(operand2);
-    return result;
+    return operand1.add(operand2);
   },
   '-': function (operand1, operand2) {
     return operand1.sub(operand2);
diff --git a/tests/suite/config/bits/computations.js b/tests/suite/config/bits/computations.js
index f08c6fd7b..3a417ead4 100644
--- a/tests/suite/config/bits/computations.js
+++ b/tests/suite/config/bits/computations.js
@@ -215,11 +215,10 @@ baseComputations.singleTest = async function (jiff_instance, test, testInputs) {
   try {
     // Share for MPC
     var shareParameters = baseComputations.shareParameters(jiff_instance, test, testInputs);
-    var shares = await baseComputations.shareHook(jiff_instance, test, testInputs, shareParameters.input, shareParameters.threshold, shareParameters.receivers, shareParameters.senders, {1: 2, 2: 2, 3: 1, 4: 2});
+    var shares = await baseComputations.shareHook(jiff_instance, test, testInputs, shareParameters.input, shareParameters.threshold, shareParameters.receivers, shareParameters.senders, {1: 2, 2: 2, 3: 1});
     if (shares == null) {
       return null;
     }
-
     shares['constant'] = shareParameters.constant;
 
     // Compute in the Open
diff --git a/tests/suite/server.js b/tests/suite/server.js
index 73732c428..928f42a70 100644
--- a/tests/suite/server.js
+++ b/tests/suite/server.js
@@ -1,5 +1,4 @@
 var extensions = process.env['JIFF_TEST_NAME'];
-console.log(extensions);
 
 var express = require('express');
 var app = express();
@@ -25,10 +24,9 @@ if (extensions != null && extensions.indexOf('restAPI') > -1) {
   app.use(bodyParser.json());
   jiff_instance.apply_extension(jiffRestAPIServer, options);
 }
-if (extensions != null && extensions.indexOf('asyncShare') > -1) {
-  console.log('async extension server');
-  jiff_instance.apply_extension(jiffAsyncShareServer, options);
-}
+//if (extensions != null && extensions.indexOf('asyncShare') != null) {
+//  jiff_instance.apply_extension(jiffAsyncShareServer, options);
+//}
 
 // Serve static files.
 app.use('/demos', express.static('demos'));

From 6422b0230af54a0ce0be9000558f27b0e2b3f43a Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Mon, 22 Jul 2019 17:30:50 -0400
Subject: [PATCH 13/24] tests

---
 lib/jiff-client.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index eac9d5a70..bcd62c8bd 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -177,12 +177,12 @@
    * @return {object} the secret share object containing the give value.
    *
    */
-  function many_secret_shares(jiff, count, holders, threshold, Zp, id, ratios) {
+  function many_secret_shares(jiff, count, holders, threshold, Zp, id) {
     var deferreds = [];
     var shares = [];
     for (var i = 0; i < count; i++) {
       var deferred = new Deferred();
-      shares.push(jiff.secret_share(jiff, false, deferred.promise, undefined, holders, threshold, Zp, 'share:' + i + ':' + id, ratios));
+      shares.push(jiff.secret_share(jiff, false, deferred.promise, undefined, holders, threshold, Zp, 'share:' + i + ':' + id));
       deferreds.push(deferred);
     }
 
@@ -2876,7 +2876,7 @@
       // generate the bits of a random number less than our prime
       var bits = self.jiff.protocols.bits.rejection_sampling(0, self.Zp, self.threshold, self.holders, self.Zp, op_id + ':sampling');
       var r = self.jiff.protocols.bits.bit_composition(bits);
-     
+
       // add and reveal random number to self
       self.jiff.internal_open(r.isadd(self), self.holders, op_id + ':open').then(function (result) {
         // compute bits assuming r+self < Zp
@@ -5239,7 +5239,7 @@
       bits1 = tmp; // longest array
 
       // initialize results
-      var result = many_secret_shares(jiff, bits1.length, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id, bits1[0].ratios);
+      var result = many_secret_shares(jiff, bits1.length, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id);
       var deferreds = result.deferreds;
       result = result.shares;
       var sum = bits1[0].isxor_bit(bits2[0], op_id + ':sxor_bit:initial');

From bbe5b000387635f2df1c6f4d7d20a535880d60ba Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Tue, 23 Jul 2019 11:59:31 -0400
Subject: [PATCH 14/24] bits test with asyncShare extension

---
 lib/ext/jiff-client-asynchronousshare.js |  1 -
 lib/jiff-client.js                       | 15 +++++++--------
 tests/suite/config/bits/arithmetic.json  |  6 +++---
 tests/suite/server.js                    |  6 +++---
 4 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/lib/ext/jiff-client-asynchronousshare.js b/lib/ext/jiff-client-asynchronousshare.js
index 08a29fdfd..79c1f99e6 100644
--- a/lib/ext/jiff-client-asynchronousshare.js
+++ b/lib/ext/jiff-client-asynchronousshare.js
@@ -148,7 +148,6 @@
     }
 
     share.add = function (o) {
-      console.log('correct adding share', share);
       if (share.isConstant(o)) {
         return share.cadd(o);
       }
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index bcd62c8bd..3049fe20c 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -177,12 +177,12 @@
    * @return {object} the secret share object containing the give value.
    *
    */
-  function many_secret_shares(jiff, count, holders, threshold, Zp, id) {
+  function many_secret_shares(jiff, count, holders, threshold, Zp, id, ratios) {
     var deferreds = [];
     var shares = [];
     for (var i = 0; i < count; i++) {
       var deferred = new Deferred();
-      shares.push(jiff.secret_share(jiff, false, deferred.promise, undefined, holders, threshold, Zp, 'share:' + i + ':' + id));
+      shares.push(jiff.secret_share(jiff, false, deferred.promise, undefined, holders, threshold, Zp, 'share:' + i + ':' + id, ratios));
       deferreds.push(deferred);
     }
 
@@ -5239,7 +5239,7 @@
       bits1 = tmp; // longest array
 
       // initialize results
-      var result = many_secret_shares(jiff, bits1.length, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id);
+      var result = many_secret_shares(jiff, bits1.length, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id, bits1[0].ratios);
       var deferreds = result.deferreds;
       result = result.shares;
       var sum = bits1[0].isxor_bit(bits2[0], op_id + ':sxor_bit:initial');
@@ -5296,7 +5296,7 @@
       bits2 = bits2.slice();
 
       // initialize results
-      var result = many_secret_shares(jiff, Math.max(bits1.length, bits2.length), bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id);
+      var result = many_secret_shares(jiff, Math.max(bits1.length, bits2.length), bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id, bits1[0].ratios);
       var deferreds = result.deferreds;
       result = result.shares;
 
@@ -5434,7 +5434,7 @@
 
       // Initialize the result
       var offset = bits2.length === 1 ? -1 : 0;
-      var result = many_secret_shares(jiff, bits1.length + bits2.length + offset, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id);
+      var result = many_secret_shares(jiff, bits1.length + bits2.length + offset, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id, bits1[0].ratios);
       var deferreds = result.deferreds;
       result = result.shares;
 
@@ -5676,11 +5676,11 @@
       bits2 = bits2.slice();
 
       // Initialize the result
-      var quotient = many_secret_shares(jiff, bits1.length, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id + ':quotient');
+      var quotient = many_secret_shares(jiff, bits1.length, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id + ':quotient', bits1[0].ratios);
       var quotientDeferreds = quotient.deferreds;
       quotient = quotient.shares;
 
-      var remainder = many_secret_shares(jiff, Math.min(bits1.length, bits2.length), bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id + ':remainder');
+      var remainder = many_secret_shares(jiff, Math.min(bits1.length, bits2.length), bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id + ':remainder', bits1[0].ratios);
       var remainderDeferreds = remainder.deferreds;
       remainder = remainder.shares;
 
@@ -5693,7 +5693,6 @@
       var initial = []; // initial remainder
       bit_combinator(final_deferred, bits1.length-1, -1, initial, function (i, _remainder) {
         var iterationCounter = (bits1.length - i - 1);
-
         // add bit i to the head of remainder (least significant bit)
         _remainder.unshift(bits1[i]);
 
diff --git a/tests/suite/config/bits/arithmetic.json b/tests/suite/config/bits/arithmetic.json
index 1c24014c9..73699a9a6 100644
--- a/tests/suite/config/bits/arithmetic.json
+++ b/tests/suite/config/bits/arithmetic.json
@@ -1,5 +1,5 @@
 {
-  "tests": [ "+" ],
+  "tests": [ "+", "-", "*", "/", "%" ],
   "suiteConf": {
     "port": 3001,
     "extensions": [ "asyncShare" ],
@@ -17,7 +17,7 @@
     "default": {
       "share": "share_bits",
       "open": "open_bits",
-      "count": 1,
+      "count": 10,
       "parallel": 3,
       "options": {
         "Zp": 127,
@@ -47,7 +47,7 @@
       }
     },
     "%": {
-      "share": "decomposition",
+      "share": "share_bits",
       "open": "composition",
       "count": 1,
       "parallel": 3,
diff --git a/tests/suite/server.js b/tests/suite/server.js
index 928f42a70..ccbf2d0d2 100644
--- a/tests/suite/server.js
+++ b/tests/suite/server.js
@@ -24,9 +24,9 @@ if (extensions != null && extensions.indexOf('restAPI') > -1) {
   app.use(bodyParser.json());
   jiff_instance.apply_extension(jiffRestAPIServer, options);
 }
-//if (extensions != null && extensions.indexOf('asyncShare') != null) {
-//  jiff_instance.apply_extension(jiffAsyncShareServer, options);
-//}
+if (extensions != null && extensions.indexOf('asyncShare') != null) {
+  jiff_instance.apply_extension(jiffAsyncShareServer, options);
+}
 
 // Serve static files.
 app.use('/demos', express.static('demos'));

From 5416146a7a01dfb96478c1c23b65451262a86c95 Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Thu, 25 Jul 2019 16:47:24 -0400
Subject: [PATCH 15/24] tests apply serverextensions

---
 tests/suite/server.js | 6 +++++-
 tests/suite/suite.sh  | 9 +++++++--
 tests/suite/test.sh   | 2 ++
 3 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/tests/suite/server.js b/tests/suite/server.js
index 8c3ca9b8e..ad142f60a 100644
--- a/tests/suite/server.js
+++ b/tests/suite/server.js
@@ -1,4 +1,8 @@
-var extensions = process.env['JIFF_TEST_NAME'];
+var name = process.env['JIFF_TEST_NAME'];
+var suite = process.env['JIFF_TEST_SUITE'];
+// JIFF test configuration
+var config = require('./config/' + name + '/' + suite + '.json');
+var extensions = config['suiteConf']['extensions'];
 
 var express = require('express');
 var app = express();
diff --git a/tests/suite/suite.sh b/tests/suite/suite.sh
index 15e844cb8..4e5ef671a 100755
--- a/tests/suite/suite.sh
+++ b/tests/suite/suite.sh
@@ -10,14 +10,17 @@ echo "====================" >> "${logs}"
 echo "NEW TEST $(date)" >> "${logs}"
 echo "====================" >> "${logs}"
 
-node tests/suite/server.js >> "${logs}" &
-
 EXIT_CODE=0
 i=0
 for f in tests/suite/config/${JIFF_TEST_NAME}/*.json; do
     FULLNAME=$(basename "$f")
     export JIFF_TEST_SUITE="${FULLNAME%.json}"
 
+    echo "test name ${JIFF_TEST_NAME}"
+    echo "test suite ${JIFF_TEST_SUITE}"
+
+    node tests/suite/server.js >> "${logs}" &
+
     if [ "$2" == "parallel" ]
     then
         ./node_modules/.bin/mocha --reporter spec tests/suite/index.js &
@@ -31,6 +34,8 @@ for f in tests/suite/config/${JIFF_TEST_NAME}/*.json; do
           EXIT_CODE=$CODE
         fi
     fi
+
+    kill $(ps aux | grep "node tests/suite/server\.js" | awk '{ print $2}')
 done
 
 if [ "$2" == "parallel" ]
diff --git a/tests/suite/test.sh b/tests/suite/test.sh
index 672cdc710..37db0a38b 100755
--- a/tests/suite/test.sh
+++ b/tests/suite/test.sh
@@ -16,6 +16,8 @@ else
   echo "====================" >> "${logs}"
   echo "NEW TEST $(date)" >> "${logs}"
   echo "====================" >> "${logs}"
+  echo "test name ${JIFF_TEST_NAME}"
+  echo "test suite ${JIFF_TEST_SUITE}"
 
   node tests/suite/server.js >> "${logs}" &
 

From 00a7a469085591f5500ab7d442d41d02994652a2 Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Tue, 30 Jul 2019 13:58:00 -0400
Subject: [PATCH 16/24] clean up arithmetic functions

---
 demos/asyncshare/mpc.js                  | 12 +++------
 lib/ext/jiff-client-asynchronousshare.js | 34 +-----------------------
 2 files changed, 5 insertions(+), 41 deletions(-)

diff --git a/demos/asyncshare/mpc.js b/demos/asyncshare/mpc.js
index 1a257be6f..24714ca0b 100644
--- a/demos/asyncshare/mpc.js
+++ b/demos/asyncshare/mpc.js
@@ -30,18 +30,14 @@
     }
 
     // The MPC implementation should go *HERE*
-    var bitLength = 9;
-    var shares = jiff_instance.protocols.bits.share_bits(input, bitLength, null, null, null, null, null, {1: 2, 2: 2, 3: 1});
+    var shares = jiff_instance.share(input, 3, null, null, null, null, {1: 1, 2: 2});
+
     var sum = shares[1];
     for (var i = 2; i <= jiff_instance.party_count; i++) {
-      sum = sum[0].jiff.protocols.bits.sadd(sum, shares[i]);
+      sum = sum.sadd(shares[i]);
     }
 
-
-
-
     // Return a promise to the final output(s)
-    var opensum = sum[0].jiff.protocols.bits.bit_composition(sum);
-    return opensum.open();
+    return jiff_instance.open(sum, [1,2]);
   };
 }((typeof exports === 'undefined' ? this.mpc = {} : exports), typeof exports !== 'undefined'));
diff --git a/lib/ext/jiff-client-asynchronousshare.js b/lib/ext/jiff-client-asynchronousshare.js
index 79c1f99e6..e249f7c19 100644
--- a/lib/ext/jiff-client-asynchronousshare.js
+++ b/lib/ext/jiff-client-asynchronousshare.js
@@ -183,22 +183,16 @@
       var ready_add = function () {
         var result = [];
         for (var i = 0; i < share.value.length; i++) {
-            result.push(jiff.helpers.mod(share_helpers['+'](share.value[i], o), share.Zp));
+          result.push(jiff.helpers.mod(share_helpers['+'](share.value[i], o), share.Zp));
         }
         return result;
       };
 
       if (share.ready) {
-        if (typeof(share.value) == 'number') {
-          return share.legacy.cadd(o);
-        }
         return share.jiff.secret_share(share.jiff, true, null, ready_add(), share.holders, share.threshold, share.Zp, null, share.ratios);
       }
 
       var promise = share.promise.then(function () {
-        if (typeof(share.value) == 'number') {
-          return (share.legacy.cadd(o)).promise;
-        }
         return ready_add();
       }, share.error);
       return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp, null, share.ratios);
@@ -225,17 +219,10 @@
       };
 
       if (share.ready && o.ready) {
-        if (typeof(share.value) == 'number') {
-          return share.legacy.sadd(o);
-        }
         return share.jiff.secret_share(share.jiff, true, null, ready_add(), share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
       }
 
       var promise = share.pick_promise(o).then( function () {
-        if (typeof(share.value) == 'number') {
-          var result = share.legacy.sadd(o);
-          return result.promise;
-        }
         return ready_add();
       }, share.error);
       return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
@@ -255,16 +242,10 @@
       };
 
       if (share.ready) {
-        if (typeof(share.value) == 'number') {
-          return share.legacy.csub(o);
-        }
         return share.jiff.secret_share(share.jiff, true, null, ready_sub(), share.holders, share.threshold, share.Zp, null, share.ratios);
       }
 
       var promise = share.promise.then(function () {
-        if (typeof(share.value) == 'number') {
-          return (share.legacy.csub(o)).promise;
-        }
         return ready_sub();
       }, share.error);
       return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp, null, share.ratios);
@@ -290,17 +271,11 @@
       };
 
       if (share.ready && o.ready) {
-        if (typeof(share.value) == 'number') {
-          return share.legacy.ssub(o);
-        }
         return share.jiff.secret_share(share.jiff, true, null, ready_sub(), share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
       }
 
       // promise to execute ready_add when both are ready
       var promise = share.pick_promise(o).then(function () {
-        if (typeof(share.value) == 'number') {
-          return (share.legacy.ssub(o).promise);
-        }
         return ready_sub();
       }, share.error);
       return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
@@ -320,16 +295,10 @@
       };
 
       if (share.ready) {
-        if (typeof(share.value) == 'number') {
-          return share.legacy.cmult(o);
-        }
         return share.jiff.secret_share(share.jiff, true, null, ready_mult(), share.holders, share.threshold, share.Zp, null, share.ratios);
       }
 
       var promise = share.promise.then(function () {
-        if (typeof(share.value) == 'number') {
-          return (share.legacy.cmult(o).promise);
-        }
         return ready_mult();
       }, share.error);
       return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp, null, share.ratios);
@@ -1117,7 +1086,6 @@
       return jiff_server_share_number(jiff, options, receivers_list, threshold, Zp, number_id);
     };
 
-
     /* HOOKS */
     jiff.hooks.createSecretShare.push(createMultipleSharesSecretShare);
     // parse content of share/open messages to be integers

From 089cc780ff946e3966d1fdfee4008ac92a35b0a6 Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Thu, 1 Aug 2019 11:33:15 -0400
Subject: [PATCH 17/24] throw error if ratios are not equal

---
 lib/ext/jiff-client-asynchronousshare.js | 45 ++++++++++++++++++++++--
 1 file changed, 42 insertions(+), 3 deletions(-)

diff --git a/lib/ext/jiff-client-asynchronousshare.js b/lib/ext/jiff-client-asynchronousshare.js
index e249f7c19..9da519f36 100644
--- a/lib/ext/jiff-client-asynchronousshare.js
+++ b/lib/ext/jiff-client-asynchronousshare.js
@@ -208,6 +208,9 @@
       if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
         throw new Error('shares must be held by the same parties (+)');
       }
+      if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
+        throw new Error('shares must have the same ratios');
+      }
 
       // add the two share when ready
       var ready_add = function () {
@@ -261,6 +264,9 @@
       if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
         throw new Error('shares must be held by the same parties (-)');
       }
+      if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
+        throw new Error('shares must have the same ratios');
+      }
 
       var ready_sub = function () {
         var result = [];
@@ -314,6 +320,9 @@
       if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
         throw new Error('shares must be held by the same parties (*)');
       }
+      if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
+        throw new Error('shares must have the same ratios');
+      }
 
       if (op_id == null) {
         op_id = share.jiff.counters.gen_op_id('*', share.holders);
@@ -372,6 +381,9 @@
       if ((share.threshold - 1) + (o.threshold - 1) > share.holders.length - 1) {
         throw new Error('threshold too high for BGW (*)');
       }
+      if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
+        throw new Error('shares must have the same ratios');
+      }
       var final_deferred = new Deferred();
       var final_promise = final_deferred.promise;
 
@@ -490,6 +502,9 @@
     };
 
     share.sdiv = function (o, l, op_id) {
+      if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
+        throw new Error('shares must have the same ratios');
+      }
       var final_deferred = new Deferred();
       var final_promise = final_deferred.promise;
 
@@ -527,6 +542,9 @@
     };
 
     share.smod = function (o, l, op_id) {
+      if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
+        throw new Error('shares must have the same ratios');
+      }
       var result, modshare;
 
       var ready_mod = function () {
@@ -622,6 +640,9 @@
     }
 
     share.slt = function (o, op_id) {
+      if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
+        throw new Error('shares must have the same ratios');
+      }
       var result = share.legacy.slt(o, op_id);
       result.ratios = share.ratios;
       return result;
@@ -656,6 +677,24 @@
       options = {};
     }
 
+    /**
+     * Check that two shares' ratios are equal.
+     * @method ratios_equals
+     * @memberof jiff-instance.helpers
+     * @instance
+     * @param {Array} ratios1 - the first share's ratios.
+     * @param {Array} ratios2 - the second share's ratios.
+     * @return {boolean} true if ratios1 is equal to ratios2, false otherwise.
+     */
+    jiff.helpers.ratios_equals = function (ratios1, ratios2) {
+      for (var p_id in ratios1) {
+        if (ratios1[p_id] !== ratios2[p_id]) {
+          return false;
+        }
+      }
+      return true;
+    };
+
     jiff.helpers.get_party_number = function (party_id, share_num, party_count) {
       if (share_num == null){
         share_num = 0;
@@ -1020,9 +1059,9 @@
         jiff.socket.safe_emit('triplet', JSON.stringify(cipher));
       }
 
-      var a_share = jiff.secret_share(jiff, false, a_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':a');
-      var b_share = jiff.secret_share(jiff, false, b_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':b');
-      var c_share = jiff.secret_share(jiff, false, c_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':c');
+      var a_share = jiff.secret_share(jiff, false, a_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':a', receivers_ratios);
+      var b_share = jiff.secret_share(jiff, false, b_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':b', receivers_ratios);
+      var c_share = jiff.secret_share(jiff, false, c_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':c', receivers_ratios);
 
       return [a_share, b_share, c_share];
     }

From cf7ea362e2bd155fc94241802603c6fcdd967c75 Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Thu, 1 Aug 2019 16:44:30 -0400
Subject: [PATCH 18/24] ratios changes

---
 lib/ext/jiff-client-asynchronousshare.js | 23 +++++++++++------------
 lib/jiff-client.js                       |  4 ++--
 2 files changed, 13 insertions(+), 14 deletions(-)

diff --git a/lib/ext/jiff-client-asynchronousshare.js b/lib/ext/jiff-client-asynchronousshare.js
index 9da519f36..e688a16fc 100644
--- a/lib/ext/jiff-client-asynchronousshare.js
+++ b/lib/ext/jiff-client-asynchronousshare.js
@@ -144,7 +144,7 @@
     };
 
     share.refresh = function (op_id) {
-      return share.isadd(share.jiff.server_generate_and_share({number: 0, ratios: share.ratios}, share.holders, share.threshold, share.Zp, op_id)[0]);
+      return share.isadd(share.jiff.server_generate_and_share({number: 0}, share.holders, share.threshold, share.Zp, op_id, share.ratios)[0]);
     }
 
     share.add = function (o) {
@@ -444,8 +444,8 @@
       var ZpOVERc = share_helpers['floor/'](share.Zp, o);
 
       // add uniform noise to self so we can open
-      var nOVERc = share.jiff.server_generate_and_share({max: ZpOVERc, ratios: share.ratios}, share.holders, share.threshold, share.Zp, op_id + ':nOVERc')[0];
-      var nMODc = share.jiff.server_generate_and_share({max: o, ratios: share.ratios}, share.holders, share.threshold, share.Zp, op_id + ':nMODc')[0];
+      var nOVERc = share.jiff.server_generate_and_share({max: ZpOVERc}, share.holders, share.threshold, share.Zp, op_id + ':nOVERc', share.ratios)[0];
+      var nMODc = share.jiff.server_generate_and_share({max: o}, share.holders, share.threshold, share.Zp, op_id + ':nMODc', share.ratios)[0];
       var noise = nOVERc.icmult(o).isadd(nMODc);
 
       var noisyX = share.isadd(noise);
@@ -611,9 +611,8 @@
       var bits = share.jiff.server_generate_and_share({
         bit: true,
         count: bitLength,
-        ratios: share.ratios
-      }, share2.holders, share2.threshold, share2.Zp, op_id + ':number:bits');
-      bits[bitLength] = share.jiff.server_generate_and_share({number: 0, ratios: share.ratios}, share2.holders, share2.threshold, share2.Zp, op_id + ':number:' + bitLength)[0]; // remove this line when fixing TODO
+      }, share2.holders, share2.threshold, share2.Zp, op_id + ':number:bits', share.ratios);
+      bits[bitLength] = share.jiff.server_generate_and_share({number: 0}, share2.holders, share2.threshold, share2.Zp, op_id + ':number:' + bitLength, share.ratios)[0]; // remove this line when fixing TODO
 
       // bit composition: r = (rl ... r1 r0)_10
       var r = share.jiff.protocols.bits.bit_composition(bits);
@@ -1070,7 +1069,7 @@
       return jiff_triplet(jiff, receivers_list, threshold, Zp, triplet_id, receivers_ratios);
     };
 
-    jiff_server_share_number = function (jiff, options, receivers_list, threshold, Zp, number_id) {
+    jiff_server_share_number = function (jiff, options, receivers_list, threshold, Zp, number_id, ratios) {
       if (Zp == null) {
         Zp = jiff.Zp;
       }
@@ -1096,7 +1095,7 @@
         options.count = 1;
       }
 
-      var msg = {number_id: number_id, receivers: receivers_list, threshold: threshold, Zp: Zp, ratios: options.ratios};
+      var msg = {number_id: number_id, receivers: receivers_list, threshold: threshold, Zp: Zp, ratios: ratios};
       msg = Object.assign(msg, options);
 
       msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'number', msg], 2);
@@ -1107,7 +1106,7 @@
       for (i = 0; i < options.count; i++) {
         var deferred = new Deferred();
         jiff.deferreds[number_id + ':' + i] = deferred;
-        shares[i] = jiff.secret_share(jiff, false, deferred.promise, undefined, receivers_list, threshold, Zp, number_id + ':' + i, options.ratios);
+        shares[i] = jiff.secret_share(jiff, false, deferred.promise, undefined, receivers_list, threshold, Zp, number_id + ':' + i, ratios);
       }
 
       // Send a request to the server.
@@ -1121,8 +1120,8 @@
       return shares;
     }
 
-    jiff.server_generate_and_share = function (options, receivers_list, threshold, Zp, number_id) {
-      return jiff_server_share_number(jiff, options, receivers_list, threshold, Zp, number_id);
+    jiff.server_generate_and_share = function (options, receivers_list, threshold, Zp, number_id, ratios) {
+      return jiff_server_share_number(jiff, options, receivers_list, threshold, Zp, number_id, ratios);
     };
 
     /* HOOKS */
@@ -1147,4 +1146,4 @@
   // Expose API
   exports.make_jiff = make_jiff;
   exports.sharing_schemes = {shamir_share: jiff_compute_shares, shamir_reconstruct: jiff_lagrange};
-}((typeof exports === 'undefined' ? this.jiff_asynchronousshare = {} : exports), typeof exports !== 'undefined'));
\ No newline at end of file
+}((typeof exports === 'undefined' ? this.jiff_asynchronousshare = {} : exports), typeof exports !== 'undefined'));
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index 3049fe20c..6dcf98f69 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -177,12 +177,12 @@
    * @return {object} the secret share object containing the give value.
    *
    */
-  function many_secret_shares(jiff, count, holders, threshold, Zp, id, ratios) {
+  function many_secret_shares(jiff, count, holders, threshold, Zp, id) {
     var deferreds = [];
     var shares = [];
     for (var i = 0; i < count; i++) {
       var deferred = new Deferred();
-      shares.push(jiff.secret_share(jiff, false, deferred.promise, undefined, holders, threshold, Zp, 'share:' + i + ':' + id, ratios));
+      shares.push(jiff.secret_share(jiff, false, deferred.promise, undefined, holders, threshold, Zp, 'share:' + i + ':' + id));
       deferreds.push(deferred);
     }
 

From b8849eafca0fecd7924ce8fadbcd3c38f2872a2c Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Fri, 2 Aug 2019 12:24:53 -0400
Subject: [PATCH 19/24] reversed changes to bits protocols

---
 lib/ext/jiff-client-asynchronousshare.js | 36 ++-------------------
 lib/jiff-client.js                       | 41 ++++++++++++++----------
 2 files changed, 26 insertions(+), 51 deletions(-)

diff --git a/lib/ext/jiff-client-asynchronousshare.js b/lib/ext/jiff-client-asynchronousshare.js
index e688a16fc..5761499e8 100644
--- a/lib/ext/jiff-client-asynchronousshare.js
+++ b/lib/ext/jiff-client-asynchronousshare.js
@@ -139,42 +139,10 @@
       return x > y ? x : y;
     }
 
-    share.open = function (parties, op_ids) {
-      return share.jiff.open(share, parties, op_ids);
-    };
-
     share.refresh = function (op_id) {
       return share.isadd(share.jiff.server_generate_and_share({number: 0}, share.holders, share.threshold, share.Zp, op_id, share.ratios)[0]);
     }
 
-    share.add = function (o) {
-      if (share.isConstant(o)) {
-        return share.cadd(o);
-      }
-      return share.sadd(o);
-    };
-
-    share.sub = function (o) {
-      if (share.isConstant(o)) {
-        return share.csub(o);
-      }
-      return share.ssub(o);
-    };
-
-    share.mult = function (o, op_id) {
-      if (share.isConstant(o)) {
-        return share.cmult(o);
-      }
-      return share.smult(o, op_id);
-    };
-
-    share.div = function (o, op_id) {
-      if (share.isConstant(o)) {
-        return share.cdiv(o, op_id);
-      }
-      return share.sdiv(o);
-    };
-
     share.cadd = function (o) {
       if (!(share.isConstant(o))) {
         throw new Error('parameter should be a number (+)');
@@ -702,9 +670,9 @@
         return party_id + (share_num * (jiff.party_count+1));
       }
       if (party_id.startsWith('s')) {
-        return parseInt(party_id.substring(1), 10) * (jiff.party_count+1); // n+1 reserved for server
+        return parseInt(party_id.substring(1), 10) * (party_count+1); // n+1 reserved for server
       }
-      return parseInt(party_id, 10) + (share_num * (jiff.party_count+1));
+      return parseInt(party_id, 10) + (share_num * (party_count+1));
     };
 
     var old_secret_share = jiff.secret_share;
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index 6dcf98f69..134e4d40f 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -366,6 +366,7 @@
         result[p_id] = jiff.secret_share(jiff, false, promise, undefined, receivers_list, threshold, Zp, share_id + ':' + p_id);
       }
     }
+
     return result;
   }
 
@@ -415,6 +416,7 @@
         power = jiff.helpers.mod(power * jiff.helpers.get_party_number(p_id), Zp);
       }
     }
+
     return shares;
   }
 
@@ -560,6 +562,7 @@
             if (final_deferred != null) {
               var recons_secret = jiff.hooks.reconstructShare(jiff, shares);
               recons_secret = jiff.execute_array_hooks('afterReconstructShare', [jiff, recons_secret], 1);
+
               final_deferred.resolve(recons_secret);
               final_deferred = null;
             }
@@ -590,7 +593,6 @@
    *
    */
   function jiff_broadcast(jiff, share, parties, op_ids) {
-
     for (var index = 0; index < parties.length; index++) {
       var i = parties[index]; // Party id
       if (i === jiff.id) {
@@ -601,6 +603,7 @@
       // encrypt, sign and send
       var msg = {party_id: i, share: share.value, op_id: op_ids[i], Zp: share.Zp};
       msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'open', msg], 2);
+
       msg['share'] = jiff.hooks.encryptSign(jiff, msg['share'].toString(), jiff.keymap[msg['party_id']], jiff.secret_key);
       jiff.socket.safe_emit('open', JSON.stringify(msg));
     }
@@ -679,6 +682,7 @@
       var tmp = jiff.helpers.mod((shares[p].value * lagrange_coeff[party]), shares[p].Zp);
       recons_secret = jiff.helpers.mod((recons_secret + tmp), shares[p].Zp);
     }
+
     return recons_secret;
   }
 
@@ -737,7 +741,6 @@
     var a_share = jiff.secret_share(jiff, false, a_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':a');
     var b_share = jiff.secret_share(jiff, false, b_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':b');
     var c_share = jiff.secret_share(jiff, false, c_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':c');
-
     return [a_share, b_share, c_share];
   }
 
@@ -749,8 +752,10 @@
    */
   function receive_triplet(jiff, json_msg) {
     json_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'triplet', json_msg], 2);
+
     var triplet = json_msg['triplet'];
     var triplet_id = json_msg['triplet_id'];
+
     if (jiff.deferreds[triplet_id] == null) {
       return;
     }
@@ -1985,7 +1990,6 @@
         throw new Error('shares must be held by the same parties (+)');
       }
 
-
       // add the two shares when ready locally
       var ready_add = function () {
         return self.jiff.helpers.mod(share_helpers['+'](self.value, o.value), self.Zp);
@@ -2085,6 +2089,7 @@
       Promise.all([e_promise, d_promise]).then(function (arr) {
         var e_open = arr[0];
         var d_open = arr[1];
+
         // result_share = d_open * e_open + d_open * b_share + e_open * a_share + c.
         var t1 = self.jiff.helpers.mod(share_helpers['*'](d_open, e_open), self.Zp);
         var t2 = b.icmult(d_open);
@@ -2138,11 +2143,11 @@
       var result = self.jiff.secret_share(self.jiff, false, final_promise, undefined, self.holders, max(self.threshold, o.threshold), self.Zp, 'share:' + op_id);
 
       Promise.all([self.promise, o.promise]).then(
-       function () {
-        // Get Shares  of z
-        var zi = self.jiff.helpers.mod(share_helpers['*'](self.value, o.value), self.Zp);
-        final_deferred.resolve(zi);
-      });
+        function () {
+          // Get Shares  of z
+          var zi = self.jiff.helpers.mod(share_helpers['*'](self.value, o.value), self.Zp);
+          final_deferred.resolve(zi);
+        });
 
       return result.change_threshold(max(self.threshold, o.threshold), op_id + ':threshold');
     };
@@ -2256,6 +2261,7 @@
       if (!self.jiff.helpers.array_equals(self.holders, o.holders)) {
         throw new Error('shares must be held by the same parties (^)');
       }
+
       return self.isadd(o).issub(self.ismult(o, op_id).icmult(2));
     };
 
@@ -2834,7 +2840,6 @@
 
       // bit composition: r = (rl ... r1 r0)_10
       var r = self.jiff.protocols.bits.bit_composition(bits);
-
       // open share + noise, and utilize opened value with shared bit representation of noise to check the least significant digit of share.
       share.jiff.internal_open(r.isadd(share), share.holders, op_id + ':open').then(function (result) {
         var wrapped = self.jiff.protocols.bits.cgt(bits, result, op_id + ':bits.cgt');
@@ -2876,7 +2881,6 @@
       // generate the bits of a random number less than our prime
       var bits = self.jiff.protocols.bits.rejection_sampling(0, self.Zp, self.threshold, self.holders, self.Zp, op_id + ':sampling');
       var r = self.jiff.protocols.bits.bit_composition(bits);
-
       // add and reveal random number to self
       self.jiff.internal_open(r.isadd(self), self.holders, op_id + ':open').then(function (result) {
         // compute bits assuming r+self < Zp
@@ -2893,6 +2897,7 @@
         }
         resolve_many_secrets(deferreds, withWrap);
       });
+
       return result;
     };
 
@@ -3460,7 +3465,6 @@
       return msg;
     });
 
-
     /**
      * Execute all hooks attached to the given name in order.
      * Hooks are executed sequentially such that the first hook's return value is passed into the second and so on.
@@ -4584,7 +4588,7 @@
      *          where the key is the party id (from 1 to n)
      *          and the value is an array of secret shared bits.
      */
-    jiff.protocols.bits.share_bits = function (secret, bit_length, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios) {
+    jiff.protocols.bits.share_bits = function (secret, bit_length, threshold, receivers_list, senders_list, Zp, share_id) {
       var i;
       if (Zp == null) {
         Zp = jiff.Zp;
@@ -4622,12 +4626,13 @@
       }
 
       for (i = 0; i < bit_length; i++) {
-        var round = jiff.internal_share(local_bits[i], threshold, receivers_list, senders_list, Zp, share_id + ':' + i, receivers_ratios);
+        var round = jiff.internal_share(local_bits[i], threshold, receivers_list, senders_list, Zp, share_id + ':' + i);
         for (var si = 0; si < senders_list.length; si++) {
           var pid = senders_list[si];
           shared_bits[pid].push(round[pid]);
         }
       }
+
       return shared_bits;
     };
 
@@ -5296,7 +5301,7 @@
       bits2 = bits2.slice();
 
       // initialize results
-      var result = many_secret_shares(jiff, Math.max(bits1.length, bits2.length), bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id, bits1[0].ratios);
+      var result = many_secret_shares(jiff, Math.max(bits1.length, bits2.length), bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id);
       var deferreds = result.deferreds;
       result = result.shares;
 
@@ -5434,7 +5439,7 @@
 
       // Initialize the result
       var offset = bits2.length === 1 ? -1 : 0;
-      var result = many_secret_shares(jiff, bits1.length + bits2.length + offset, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id, bits1[0].ratios);
+      var result = many_secret_shares(jiff, bits1.length + bits2.length + offset, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id);
       var deferreds = result.deferreds;
       result = result.shares;
 
@@ -5676,11 +5681,11 @@
       bits2 = bits2.slice();
 
       // Initialize the result
-      var quotient = many_secret_shares(jiff, bits1.length, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id + ':quotient', bits1[0].ratios);
+      var quotient = many_secret_shares(jiff, bits1.length, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id + ':quotient');
       var quotientDeferreds = quotient.deferreds;
       quotient = quotient.shares;
 
-      var remainder = many_secret_shares(jiff, Math.min(bits1.length, bits2.length), bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id + ':remainder', bits1[0].ratios);
+      var remainder = many_secret_shares(jiff, Math.min(bits1.length, bits2.length), bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id + ':remainder');
       var remainderDeferreds = remainder.deferreds;
       remainder = remainder.shares;
 
@@ -5693,6 +5698,7 @@
       var initial = []; // initial remainder
       bit_combinator(final_deferred, bits1.length-1, -1, initial, function (i, _remainder) {
         var iterationCounter = (bits1.length - i - 1);
+
         // add bit i to the head of remainder (least significant bit)
         _remainder.unshift(bits1[i]);
 
@@ -6237,6 +6243,7 @@
         msg = jiff.hooks.decryptSign(jiff, msg, jiff.secret_key, jiff.keymap['s1']);
         msg = JSON.parse(msg);
       }
+
       // parse message
       receive_triplet(jiff, msg);
     });

From 7272c950eb5238958e68a9848ac086d416e8477d Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Fri, 2 Aug 2019 17:11:12 -0400
Subject: [PATCH 20/24] secret clone & jiff.socket

---
 lib/ext/jiff-client-asynchronousshare.js | 287 +++++++++++++----------
 lib/jiff-client.js                       |  20 +-
 2 files changed, 170 insertions(+), 137 deletions(-)

diff --git a/lib/ext/jiff-client-asynchronousshare.js b/lib/ext/jiff-client-asynchronousshare.js
index 5761499e8..db30e7515 100644
--- a/lib/ext/jiff-client-asynchronousshare.js
+++ b/lib/ext/jiff-client-asynchronousshare.js
@@ -10,29 +10,7 @@
    */
   exports.name = 'asyncshare';
 
-  function Deferred() {
-    // Polyfill for jQuery Deferred
-    // From https://developer.mozilla.org/en-US/docs/Mozilla/JavaScript_code_modules/Promise.jsm/Deferred
-    this.resolve = null;
-
-    /* A method to reject the associated Promise with the value passed.
-     * If the promise is already settled it does nothing.
-     *
-     * @param {anything} reason: The reason for the rejection of the Promise.
-     * Generally its an Error object. If however a Promise is passed, then the Promise
-     * itself will be the reason for rejection no matter the state of the Promise.
-     */
-    this.reject = null;
-
-    /* A newly created Promise object.
-     * Initially in pending state.
-     */
-    this.promise = new Promise(function (resolve, reject) {
-      this.resolve = resolve;
-      this.reject = reject;
-    }.bind(this));
-    Object.freeze(this);
-  }
+  $ = require('jquery-deferred');
 
   // export functions
   function jiff_compute_shares(jiff, secret, parties_list, threshold, Zp, parties_ratios) {
@@ -143,6 +121,19 @@
       return share.isadd(share.jiff.server_generate_and_share({number: 0}, share.holders, share.threshold, share.Zp, op_id, share.ratios)[0]);
     }
 
+    /** Creates a clone of the share with same properties (holders, threshold, etc.)
+     */
+    share.secret_clone = function(ready, promise, value, threshold, holders, Zp, id, ratios) {
+      var threshold = threshold == undefined ? share.threshold : threshold;
+      var holders = holders == undefined ? share.holders : holders;
+      var Zp = Zp == undefined ? share.Zp : Zp;
+      var id = id == undefined ? null : id;
+      var ratios = ratios == undefined ? share.ratios : ratios;
+
+      var clone = jiff.secret_share(share.jiff, ready, promise, value, holders, threshold, Zp, id, ratios);
+      return clone;
+    };
+
     share.cadd = function (o) {
       if (!(share.isConstant(o))) {
         throw new Error('parameter should be a number (+)');
@@ -157,25 +148,17 @@
       };
 
       if (share.ready) {
-        return share.jiff.secret_share(share.jiff, true, null, ready_add(), share.holders, share.threshold, share.Zp, null, share.ratios);
+        return share.secret_clone(true, null, ready_add());
       }
 
       var promise = share.promise.then(function () {
         return ready_add();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp, null, share.ratios);
+      return share.secret_clone(false, promise, null);
     };
 
     share.sadd = function (o) {
-      if (!(o.jiff === share.jiff)) {
-        throw new Error('shares do not belong to the same instance (+)');
-      }
-      if (!share.jiff.helpers.Zp_equals(share, o)) {
-        throw new Error('shares must belong to the same field (+)');
-      }
-      if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
-        throw new Error('shares must be held by the same parties (+)');
-      }
+      (share.jiff.helpers.shares_compatible(share, o));
       if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
         throw new Error('shares must have the same ratios');
       }
@@ -190,13 +173,13 @@
       };
 
       if (share.ready && o.ready) {
-        return share.jiff.secret_share(share.jiff, true, null, ready_add(), share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
+        return share.secret_clone(true, null, ready_add(), max(share.threshold, o.threshold));
       }
 
       var promise = share.pick_promise(o).then( function () {
         return ready_add();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
+      return share.secret_clone(false, promise, null, max(share.threshold, o.threshold));
     };
 
     share.csub = function (o) {
@@ -213,25 +196,17 @@
       };
 
       if (share.ready) {
-        return share.jiff.secret_share(share.jiff, true, null, ready_sub(), share.holders, share.threshold, share.Zp, null, share.ratios);
+        return share.secret_clone(true, null, ready_sub());
       }
 
       var promise = share.promise.then(function () {
         return ready_sub();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp, null, share.ratios);
+      return share.secret_clone(false, promise, null);
     };
 
     share.ssub = function (o) {
-      if (!(o.jiff === share.jiff)) {
-        throw new Error('shares do not belong to the same instance (-)');
-      }
-      if (!share.jiff.helpers.Zp_equals(share, o)) {
-        throw new Error('shares must belong to the same field (-)');
-      }
-      if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
-        throw new Error('shares must be held by the same parties (-)');
-      }
+      (share.jiff.helpers.shares_compatible(share, o));
       if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
         throw new Error('shares must have the same ratios');
       }
@@ -245,14 +220,14 @@
       };
 
       if (share.ready && o.ready) {
-        return share.jiff.secret_share(share.jiff, true, null, ready_sub(), share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
+        return share.secret_clone(true, null, ready_sub(), max(share.threshold, o.threshold));
       }
 
       // promise to execute ready_add when both are ready
       var promise = share.pick_promise(o).then(function () {
         return ready_sub();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
+      return share.secret_clone(false, promise, null, max(share.threshold, o.threshold));
     };
 
     share.cmult = function (o) {
@@ -269,25 +244,17 @@
       };
 
       if (share.ready) {
-        return share.jiff.secret_share(share.jiff, true, null, ready_mult(), share.holders, share.threshold, share.Zp, null, share.ratios);
+        return share.secret_clone(true, null, ready_mult());
       }
 
       var promise = share.promise.then(function () {
         return ready_mult();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp, null, share.ratios);
+      return share.secret_clone(false, promise, null);
     };
 
     share.smult = function (o, op_id) {
-      if (!(o.jiff === share.jiff)) {
-        throw new Error('shares do not belong to the same instance (*)');
-      }
-      if (!share.jiff.helpers.Zp_equals(share, o)) {
-        throw new Error('shares must belong to the same field (*)');
-      }
-      if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
-        throw new Error('shares must be held by the same parties (*)');
-      }
+      (share.jiff.helpers.shares_compatible(share, o));
       if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
         throw new Error('shares must have the same ratios');
       }
@@ -296,9 +263,9 @@
         op_id = share.jiff.counters.gen_op_id('*', share.holders);
       }
 
-      var final_deferred = new Deferred();
-      var final_promise = final_deferred.promise;
-      var result = share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp, 'share:' + op_id, share.ratios);
+      var final_deferred = $.Deferred();
+      var final_promise = final_deferred.promise();
+      var result = share.secret_clone(false, final_promise, undefined, max(share.threshold, o.threshold), undefined, undefined, 'share:' + op_id);
 
       // Get shares of triplets.
       var triplet = jiff.triplet(share.holders, max(share.threshold, o.threshold), share.Zp, op_id + ':triplet', share.ratios);
@@ -337,31 +304,24 @@
     };
 
     share.smult_bgw = function(o, op_id) {
-      if (!(o.jiff === share.jiff)) {
-        throw new Error('shares do not belong to the same instance (bgw*)');
-      }
-      if (!share.jiff.helpers.Zp_equals(share, o)) {
-        throw new Error('shares must belong to the same field (bgw*)');
-      }
-      if (!share.jiff.helpers.array_equals(share.holders, o.holders)) {
-        throw new Error('shares must be held by the same parties (bgw*)');
-      }
+      (share.jiff.helpers.shares_compatible(share, o));
       if ((share.threshold - 1) + (o.threshold - 1) > share.holders.length - 1) {
         throw new Error('threshold too high for BGW (*)');
       }
       if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
         throw new Error('shares must have the same ratios');
       }
-      var final_deferred = new Deferred();
-      var final_promise = final_deferred.promise;
+
+      var final_deferred = $.Deferred();
+      var final_promise = final_deferred.promise();
 
       var ready_mult_bgw = function () {
         var result = [];
         var promises = [];
 
         for (var i = 0; i < share.value.length; i++) {
-          var share_tmp = jiff.secret_share(share.jiff, true, null, share.value[i], share.holders, share.threshold, share.Zp);
-          var o_tmp = jiff.secret_share(o.jiff, true, null, o.value[i], o.holders, o.threshold, o.Zp);
+          var share_tmp = share.secret_clone(true, null, share.value[i]);
+          var o_tmp = o.secret_clone(true, null, o.value[i]);
           var multshare = share_tmp.legacy.smult_bgw(o_tmp, op_id);
           promises.push(multshare.promise);
 
@@ -377,14 +337,14 @@
 
       if (share.ready && o.ready) {
         ready_mult_bgw();
-        return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+        return share.secret_clone(false, final_promise, undefined, max(share.threshold, o.threshold));
       }
 
       // promise to execute ready_add when both are ready
       share.pick_promise(o).then( function () {
         ready_mult_bgw();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.secret_clone(false, final_promise, undefined, max(share.threshold, o.threshold));
     };
 
     share.cdiv = function (o, op_id) {
@@ -405,9 +365,9 @@
       }
 
       // Allocate share for result to which the answer will be resolved once available
-      var final_deferred = new Deferred();
-      var final_promise = final_deferred.promise;
-      var result = share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, share.threshold, share.Zp, 'share:' + op_id, share.ratios);
+      var final_deferred = $.Deferred();
+      var final_promise = final_deferred.promise();
+      var result = share.secret_clone(false, final_promise, undefined, max(share.threshold, o.threshold), undefined, undefined,'share:' + op_id);
 
       var ZpOVERc = share_helpers['floor/'](share.Zp, o);
 
@@ -460,29 +420,29 @@
 
       if (share.ready) {
         // If share is ready.
-        return share.jiff.secret_share(share.jiff, true, null, ready_cdivfac(), share.holders, share.threshold, share.Zp, null, share.ratios);
+        return share.secret_clone(true, null, ready_cdivfac());
       }
 
       var promise = share.promise.then(function () {
         return ready_cdivfac();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, promise, undefined, share.holders, share.threshold, share.Zp, null, share.ratios);
+      return share.secret_clone(false, promise, undefined);
     };
 
     share.sdiv = function (o, l, op_id) {
       if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
         throw new Error('shares must have the same ratios');
       }
-      var final_deferred = new Deferred();
-      var final_promise = final_deferred.promise;
+      var final_deferred = $.Deferred();
+      var final_promise = final_deferred.promise();
 
       var ready_div = function () {
         var result = [];
         var promises = [];
 
         for (var i = 0; i < share.value.length; i++) {
-          var share_tmp = jiff.secret_share(share.jiff, true, null, share.value[i], share.holders, share.threshold, share.Zp, null, share.ratios);
-          var o_tmp = jiff.secret_share(o.jiff, true, null, o.value[i], o.holders, o.threshold, o.Zp, null, o.ratios);
+          var share_tmp = share.secret_clone(true, null, share.value[i]);
+          var o_tmp = o.secret_clone(true, null, o.value[i]);
           var divshare = share_tmp.legacy.sdiv(o_tmp, l, op_id + ':' + i);
           promises.push(divshare.promise);
 
@@ -499,14 +459,14 @@
 
       if (share.ready && o.ready) {
         ready_div();
-        return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp, null, share.ratios);
+        return share.secret_clone(false, final_promise, undefined, max(share.threshold, o.threshold));
       }
 
       // promise to execute ready_add when both are ready
       share.pick_promise(o).then( function () {
         ready_div();
       }, share.error);
-      return share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, max(share.threshold, o.threshold), share.Zp);
+      return share.secret_clone(false, final_promise, undefined, max(share.threshold, o.threshold));
     };
 
     share.smod = function (o, l, op_id) {
@@ -567,9 +527,9 @@
         op_id = share.jiff.counters.gen_op_id('lt_hp', share.holders);
       }
 
-      var final_deferred = new Deferred();
-      var final_promise = final_deferred.promise;
-      var result = share.jiff.secret_share(share.jiff, false, final_promise, undefined, share.holders, share.threshold, share.Zp, 'share:' + op_id, share.ratios);
+      var final_deferred = $.Deferred();
+      var final_promise = final_deferred.promise();
+      var result = share.secret_clone(false, final_promise, undefined, undefined, undefined, undefined, 'share:' + op_id);
 
       // if 2*self is even, then self is less than half prime, otherwise self is greater or equal to half prime
       var share2 = share.icmult(2);
@@ -644,6 +604,27 @@
       options = {};
     }
 
+    /**
+     * Check that two shares are compatible
+     * @method shares_compatible
+     * @memberof jiff-instance.helpers
+     * @instance
+     * @param {SecretShare} s1 - first share
+     * @param {SecretShare} s2 - second share
+     * @return {boolean} true if shares are compatible, false otherwise.
+     */
+    jiff.helpers.shares_compatible = function (s1, s2){
+      if (!(s2.jiff === s1.jiff)) {
+        throw new Error('shares do not belong to the same instance (+)');
+      }
+      if (!jiff.helpers.Zp_equals(s1, s2)) {
+        throw new Error('shares must belong to the same field (Zp)');
+      }
+      if (!jiff.helpers.array_equals(s1.holders, s2.holders)) {
+        throw new Error('shares must be held by the same parties');
+      }
+    };
+
     /**
      * Check that two shares' ratios are equal.
      * @method ratios_equals
@@ -684,22 +665,30 @@
       return share;
     };
 
-    function jiff_broadcast(jiff, share, parties, op_ids) {
-      for (var index = 0; index < parties.length; index++) {
-        var i = parties[index]; // Party id
-        if (i === jiff.id) {
-          receive_open(jiff, {party_id: i, share: share.value, op_id: op_ids[i], Zp: share.Zp});
-          continue;
-        }
+    function receive_share(jiff, json_msg) {
+      // Decrypt share
+      for (var i = 0; i < json_msg['share'].length; i++) {
+        json_msg['share'][i] = jiff.hooks.decryptSign(jiff, json_msg['share'][i], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
+      }
+      json_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'share', json_msg], 2);
+      var sender_id = json_msg['party_id'];
+      var op_id = json_msg['op_id'];
+      var share = json_msg['share'];
 
-        // encrypt, sign and send
-        var msg = {party_id: i, share: share.value.slice(), op_id: op_ids[i], Zp: share.Zp};
-        msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'open', msg], 2);
-        for (var j = 0; j < msg['share'].length; j++) {
-          msg['share'][j] = jiff.hooks.encryptSign(jiff, msg['share'][j].toString(), jiff.keymap[msg['party_id']], jiff.secret_key);
-        }
-        jiff.socket.safe_emit('open', JSON.stringify(msg));
+      // Call hook
+      share = jiff.execute_array_hooks('receiveShare', [jiff, sender_id, share], 2);
+
+      // check if a deferred is set up (maybe the share was received early)
+      if (jiff.deferreds[op_id] == null) {
+        jiff.deferreds[op_id] = {};
+      }
+      if (jiff.deferreds[op_id][sender_id] == null) {
+        // Share is received before deferred was setup, store it.
+        jiff.deferreds[op_id][sender_id] = $.Deferred();
       }
+
+      // Deferred is already setup, resolve it.
+      jiff.deferreds[op_id][sender_id].resolve(share);
     }
 
     function receive_open(jiff, json_msg) {
@@ -724,12 +713,30 @@
         jiff.deferreds[op_id] = {};
       }
       if (jiff.deferreds[op_id][sender_id] == null) {
-        jiff.deferreds[op_id][sender_id] = new Deferred();
+        jiff.deferreds[op_id][sender_id] = $.Deferred();
       }
 
       jiff.deferreds[op_id][sender_id].resolve({value: share, sender_id: sender_id, Zp: Zp});
     }
 
+    function jiff_broadcast(jiff, share, parties, op_ids) {
+      for (var index = 0; index < parties.length; index++) {
+        var i = parties[index]; // Party id
+        if (i === jiff.id) {
+          receive_open(jiff, {party_id: i, share: share.value, op_id: op_ids[i], Zp: share.Zp});
+          continue;
+        }
+
+        // encrypt, sign and send
+        var msg = {party_id: i, share: share.value.slice(), op_id: op_ids[i], Zp: share.Zp};
+        msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'open', msg], 2);
+        for (var j = 0; j < msg['share'].length; j++) {
+          msg['share'][j] = jiff.hooks.encryptSign(jiff, msg['share'][j].toString(), jiff.keymap[msg['party_id']], jiff.secret_key);
+        }
+        jiff.socket.safe_emit('open', JSON.stringify(msg));
+      }
+    }
+
     jiff_open = function(jiff, share, parties, op_ids) {
       var i;
 
@@ -798,8 +805,8 @@
       if (parties.indexOf(jiff.id) > -1) {
         var shares = []; // this will store received shares
         var numberofshares = 0;
-        var final_deferred = new Deferred(); // will be resolved when the final value is reconstructed
-        var final_promise = final_deferred.promise;
+        var final_deferred = $.Deferred(); // will be resolved when the final value is reconstructed
+        var final_promise = final_deferred.promise();
         for (i = 0; i < share.holders.length; i++) {
           var p_id = share.holders[i];
 
@@ -808,11 +815,11 @@
             jiff.deferreds[op_ids[jiff.id]] = {};
           }
           if (jiff.deferreds[op_ids[jiff.id]][p_id] == null) {
-            jiff.deferreds[op_ids[jiff.id]][p_id] = new Deferred();
+            jiff.deferreds[op_ids[jiff.id]][p_id] = $.Deferred();
           }
 
           // Clean up deferred when fulfilled
-          var promise = jiff.deferreds[op_ids[jiff.id]][p_id].promise;
+          var promise = jiff.deferreds[op_ids[jiff.id]][p_id].promise();
 
           // destroy deferred when done
           (function (promise, p_id) { // p_id is modified in a for loop, must do this to avoid scoping issues.
@@ -949,10 +956,10 @@
           // check if a deferred is set up (maybe the message was previously received)
           if (jiff.deferreds[share_id][p_id] == null) {
             // not ready, setup a deferred
-            jiff.deferreds[share_id][p_id] = new Deferred();
+            jiff.deferreds[share_id][p_id] = $.Deferred();
           }
 
-          var promise = jiff.deferreds[share_id][p_id].promise;
+          var promise = jiff.deferreds[share_id][p_id].promise();
 
           // destroy deferred when done
           (function (promise, p_id) { // p_id is modified in a for loop, must do this to avoid scoping issues.
@@ -1013,9 +1020,9 @@
       msg = JSON.stringify(msg);
 
       // Setup deferred to handle receiving the triplets later.
-      var a_deferred = new Deferred();
-      var b_deferred = new Deferred();
-      var c_deferred = new Deferred();
+      var a_deferred = $.Deferred();
+      var b_deferred = $.Deferred();
+      var c_deferred = $.Deferred();
       jiff.deferreds[triplet_id] = {a: a_deferred, b: b_deferred, c: c_deferred};
 
       // send a request to the server.
@@ -1026,9 +1033,9 @@
         jiff.socket.safe_emit('triplet', JSON.stringify(cipher));
       }
 
-      var a_share = jiff.secret_share(jiff, false, a_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':a', receivers_ratios);
-      var b_share = jiff.secret_share(jiff, false, b_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':b', receivers_ratios);
-      var c_share = jiff.secret_share(jiff, false, c_deferred.promise, undefined, receivers_list, threshold, Zp, triplet_id + ':c', receivers_ratios);
+      var a_share = jiff.secret_share(jiff, false, a_deferred.promise(), undefined, receivers_list, threshold, Zp, triplet_id + ':a', receivers_ratios);
+      var b_share = jiff.secret_share(jiff, false, b_deferred.promise(), undefined, receivers_list, threshold, Zp, triplet_id + ':b', receivers_ratios);
+      var c_share = jiff.secret_share(jiff, false, c_deferred.promise(), undefined, receivers_list, threshold, Zp, triplet_id + ':c', receivers_ratios);
 
       return [a_share, b_share, c_share];
     }
@@ -1072,9 +1079,9 @@
       // Setup deferreds to handle receiving the triplets later.
       var shares = [];
       for (i = 0; i < options.count; i++) {
-        var deferred = new Deferred();
+        var deferred = $.Deferred();
         jiff.deferreds[number_id + ':' + i] = deferred;
-        shares[i] = jiff.secret_share(jiff, false, deferred.promise, undefined, receivers_list, threshold, Zp, number_id + ':' + i, ratios);
+        shares[i] = jiff.secret_share(jiff, false, deferred.promise(), undefined, receivers_list, threshold, Zp, number_id + ':' + i, ratios);
       }
 
       // Send a request to the server.
@@ -1092,6 +1099,44 @@
       return jiff_server_share_number(jiff, options, receivers_list, threshold, Zp, number_id, ratios);
     };
 
+    // Change set up of receiving matching shares to call correct receive_share function
+    jiff.socket.off('share');
+    jiff.socket.on('share', function (msg, callback) {
+      callback(true); // send ack to server
+
+      // parse message
+      var json_msg = JSON.parse(msg);
+      var sender_id = json_msg['party_id'];
+
+      if (jiff.keymap[sender_id] != null) {
+        receive_share(jiff, json_msg);
+      } else {
+        if (jiff.messagesWaitingKeys[sender_id] == null) {
+          jiff.messagesWaitingKeys[sender_id] = [];
+        }
+        jiff.messagesWaitingKeys[sender_id].push({label: 'share', msg: json_msg});
+      }
+    });
+
+    // Change set up of opening shares to call correct receive_open function
+    jiff.socket.off('open');
+    jiff.socket.on('open', function (msg, callback) {
+      callback(true); // send ack to server
+
+      // parse message
+      var json_msg = JSON.parse(msg);
+      var sender_id = json_msg['party_id'];
+
+      if (jiff.keymap[sender_id] != null) {
+        receive_open(jiff, json_msg);
+      } else {
+        if (jiff.messagesWaitingKeys[sender_id] == null) {
+          jiff.messagesWaitingKeys[sender_id] = [];
+        }
+        jiff.messagesWaitingKeys[sender_id].push({ label: 'open', msg: json_msg });
+      }
+    });
+
     /* HOOKS */
     jiff.hooks.createSecretShare.push(createMultipleSharesSecretShare);
     // parse content of share/open messages to be integers
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index 134e4d40f..7b6d08ad8 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -429,15 +429,9 @@
    */
   function receive_share(jiff, json_msg) {
     // Decrypt share
-    if (json_msg['share'].length >= 1) {
-      for (var i = 0; i < json_msg['share'].length; i++) {
-        json_msg['share'][i] = jiff.hooks.decryptSign(jiff, json_msg['share'][i], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
-      }
-    } else {
-      json_msg['share'] = jiff.hooks.decryptSign(jiff, json_msg['share'], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
-    }
-
+    json_msg['share'] = jiff.hooks.decryptSign(jiff, json_msg['share'], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
     json_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'share', json_msg], 2);
+
     var sender_id = json_msg['party_id'];
     var op_id = json_msg['op_id'];
     var share = json_msg['share'];
@@ -618,13 +612,7 @@
   function receive_open(jiff, json_msg) {
     // Decrypt share
     if (json_msg['party_id'] !== jiff.id) {
-      if (json_msg['share'].length >= 1) {
-        for (var i = 0; i < json_msg['share'].length; i++) {
-          json_msg['share'][i] = jiff.hooks.decryptSign(jiff, json_msg['share'][i], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
-        }
-      } else {
-        json_msg['share'] = jiff.hooks.decryptSign(jiff, json_msg['share'], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
-      }
+      json_msg['share'] = jiff.hooks.decryptSign(jiff, json_msg['share'], jiff.secret_key, jiff.keymap[json_msg['party_id']]);
       json_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'open', json_msg], 2);
     }
 
@@ -5244,7 +5232,7 @@
       bits1 = tmp; // longest array
 
       // initialize results
-      var result = many_secret_shares(jiff, bits1.length, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id, bits1[0].ratios);
+      var result = many_secret_shares(jiff, bits1.length, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id);
       var deferreds = result.deferreds;
       result = result.shares;
       var sum = bits1[0].isxor_bit(bits2[0], op_id + ':sxor_bit:initial');

From f6778e17e6a9a41060a65f6b2fb52d1ae8b17d21 Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Fri, 2 Aug 2019 17:21:05 -0400
Subject: [PATCH 21/24] remove changes to base jiff-client

---
 lib/jiff-client.js          | 1 +
 lib/jiff-server.js          | 1 -
 tests/suite/computations.js | 7 ++++---
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index 7b6d08ad8..a9201d37e 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -5235,6 +5235,7 @@
       var result = many_secret_shares(jiff, bits1.length, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, op_id);
       var deferreds = result.deferreds;
       result = result.shares;
+
       var sum = bits1[0].isxor_bit(bits2[0], op_id + ':sxor_bit:initial');
       var carry = bits1[0].ismult(bits2[0], op_id + ':smult:initial');
 
diff --git a/lib/jiff-server.js b/lib/jiff-server.js
index 030ad2493..c302f0714 100644
--- a/lib/jiff-server.js
+++ b/lib/jiff-server.js
@@ -36,7 +36,6 @@ function secureRandom(max) {
     }
   }
 }
-
 function mod(x, y) {
   if (x < 0) {
     return (x % y) + y;
diff --git a/tests/suite/computations.js b/tests/suite/computations.js
index 023e54704..7c9ef72e2 100644
--- a/tests/suite/computations.js
+++ b/tests/suite/computations.js
@@ -192,9 +192,9 @@ exports.singleCompute = function (jiff_instance, shareParameters, test, values,
 
     // Compute
     var result = func(values[indices[0]], values[indices[1]]);
-    //for (var i = 2; i < indices.length; i++) {
-    //  result = func(result, values[indices[i]]);
-    //}
+    for (var i = 2; i < indices.length; i++) {
+      result = func(result, values[indices[i]]);
+    }
     return result;
   } catch (err) {
     console.log(err);
@@ -238,6 +238,7 @@ exports.singleTest = async function (jiff_instance, test, testInputs) {
     errors.push(err);
     return false;
   }
+  
   return true;
 };
 

From 04d5e7073275209e088e4f31f50bc2e3b384600d Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Fri, 2 Aug 2019 17:30:01 -0400
Subject: [PATCH 22/24] remove asyncShare extension from bits

---
 tests/suite/computations.js                |  2 +-
 tests/suite/config/bits/arithmetic.json    | 11 +++--
 tests/suite/config/bits/computations.js    | 52 +++-------------------
 tests/suite/config/bits/decomposition.json |  3 +-
 4 files changed, 12 insertions(+), 56 deletions(-)

diff --git a/tests/suite/computations.js b/tests/suite/computations.js
index 7c9ef72e2..8b1420a0d 100644
--- a/tests/suite/computations.js
+++ b/tests/suite/computations.js
@@ -238,7 +238,7 @@ exports.singleTest = async function (jiff_instance, test, testInputs) {
     errors.push(err);
     return false;
   }
-  
+
   return true;
 };
 
diff --git a/tests/suite/config/bits/arithmetic.json b/tests/suite/config/bits/arithmetic.json
index 73699a9a6..c215174b4 100644
--- a/tests/suite/config/bits/arithmetic.json
+++ b/tests/suite/config/bits/arithmetic.json
@@ -2,7 +2,6 @@
   "tests": [ "+", "-", "*", "/", "%" ],
   "suiteConf": {
     "port": 3001,
-    "extensions": [ "asyncShare" ],
     "generation": {
       "file": "config/bits/generation.js",
       "function": "generateArithmeticInputs"
@@ -28,7 +27,7 @@
     "*": {
       "share": "share_bits",
       "open": "open_bits",
-      "count": 1,
+      "count": 10,
       "parallel": 3,
       "options": {
         "Zp": 127,
@@ -39,7 +38,7 @@
     "/": {
       "share": "share_bits",
       "open": "composition",
-      "count": 1,
+      "count": 10,
       "parallel": 3,
       "options": {
         "Zp": 127,
@@ -47,9 +46,9 @@
       }
     },
     "%": {
-      "share": "share_bits",
+      "share": "decomposition",
       "open": "composition",
-      "count": 1,
+      "count": 10,
       "parallel": 3,
       "options": {
         "Zp": 127,
@@ -57,4 +56,4 @@
       }
     }
   }
-}
\ No newline at end of file
+}
diff --git a/tests/suite/config/bits/computations.js b/tests/suite/config/bits/computations.js
index 3a417ead4..028ef1d6f 100644
--- a/tests/suite/config/bits/computations.js
+++ b/tests/suite/config/bits/computations.js
@@ -3,10 +3,6 @@ var baseComputations = require('../../computations.js');
 
 var testConfig;
 
-// Flags success/failure
-var errors = [];
-var successes = [];
-
 // How to interpret non-MPC operations
 baseComputations.openInterpreter = {
   'decomposition': function (operand1) {
@@ -146,10 +142,10 @@ baseComputations.mpcInterpreter = {
 };
 
 // Sharing bits
-baseComputations.shareHook = async function (jiff_instance, test, testInputs, input, threshold, receivers, senders, ratios) {
+baseComputations.shareHook = async function (jiff_instance, test, testInputs, input, threshold, receivers, senders) {
   var shares = {};
   if (testConfig['share'] == null || testConfig['share'] === 'decomposition') {
-    shares = jiff_instance.share(input, threshold, receivers, senders, jiff_instance.Zp, null, ratios);
+    shares = jiff_instance.share(input, threshold, receivers, senders);
     var i, pid;
     for (i = 0; i < senders.length; i++) {
       pid = senders[i];
@@ -162,7 +158,7 @@ baseComputations.shareHook = async function (jiff_instance, test, testInputs, in
   if (testConfig['share'] === 'share_bits') {
     var bitLength = testConfig['options']['max'] || jiff_instance.Zp;
     bitLength = bitLength.toString(2).length;
-    shares = jiff_instance.protocols.bits.share_bits(input, bitLength, threshold, receivers, senders, jiff_instance.Zp, null, ratios);
+    shares = jiff_instance.protocols.bits.share_bits(input, bitLength, threshold, receivers, senders);
   }
 
   if (testConfig['share'] === 'share_bits_lengths') {
@@ -173,7 +169,7 @@ baseComputations.shareHook = async function (jiff_instance, test, testInputs, in
       if (bitLength == null) {
         bitLength = input.toString(2).length;
       }
-      shares[sender] = jiff_instance.protocols.bits.share_bits(input, bitLength, threshold, receivers, [sender], jiff_instance.Zp, null, ratios)[sender];
+      shares[sender] = jiff_instance.protocols.bits.share_bits(input, bitLength, threshold, receivers, [sender])[sender];
     }
   }
   return shares;
@@ -211,46 +207,8 @@ baseComputations.verifyResultHook = function (test, mpcResult, expectedResult) {
   return (mpcResult.toString() === expectedResult.toString());
 };
 
-baseComputations.singleTest = async function (jiff_instance, test, testInputs) {
-  try {
-    // Share for MPC
-    var shareParameters = baseComputations.shareParameters(jiff_instance, test, testInputs);
-    var shares = await baseComputations.shareHook(jiff_instance, test, testInputs, shareParameters.input, shareParameters.threshold, shareParameters.receivers, shareParameters.senders, {1: 2, 2: 2, 3: 1});
-    if (shares == null) {
-      return null;
-    }
-    shares['constant'] = shareParameters.constant;
-
-    // Compute in the Open
-    var actualResult = await baseComputations.singleCompute(jiff_instance, shareParameters, test, testInputs, baseComputations.openInterpreter);
-
-    // Compute under MPC
-    var mpcResult = await baseComputations.singleCompute(jiff_instance, shareParameters, test, shares, baseComputations.mpcInterpreter);
-    if (mpcResult == null) {
-      return null;
-    }
-
-    // Open
-    mpcResult = await baseComputations.openHook(jiff_instance, test, mpcResult);
-
-    // Verify result
-    // Assert both results are equal
-    if (!baseComputations.verifyResultHook(test, mpcResult, actualResult)) {
-      errors.push(baseComputations.errorMessage(jiff_instance, test, testInputs, shareParameters, mpcResult, actualResult));
-      return false;
-    }
-
-    successes.push(baseComputations.successMessage(jiff_instance, test, testInputs, shareParameters, mpcResult, actualResult));
-  } catch (err) {
-    console.log(err);
-    errors.push(err);
-    return false;
-  }
-  return true;
-};
-
 // Default Computation Scheme
 exports.compute = function (_jiff_instance, _test, _inputs, _testParallel, _done, _testConfig) {
   testConfig = _testConfig;
   return baseComputations.compute.apply(baseComputations, arguments);
-};
\ No newline at end of file
+};
diff --git a/tests/suite/config/bits/decomposition.json b/tests/suite/config/bits/decomposition.json
index 3274a2619..66e8e931e 100644
--- a/tests/suite/config/bits/decomposition.json
+++ b/tests/suite/config/bits/decomposition.json
@@ -3,7 +3,6 @@
              "decomposition-open-2-15485867", "decomposition-open-3-15485867", "decomposition-open-5-2039" ],
   "suiteConf": {
     "port": 3001,
-    "extensions" : ["asyncShare"],
     "generation": {
       "file": "config/bits/generation.js",
       "function": "generateDecomposition"
@@ -100,4 +99,4 @@
       }
     }
   }
-}
\ No newline at end of file
+}

From 75c87fa42be9e8aae6b25a1b7bcca9602e5a0b3a Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Mon, 5 Aug 2019 14:56:18 -0400
Subject: [PATCH 23/24] changes from code review

---
 lib/ext/jiff-client-asynchronousshare.js | 132 ++++++++++++-----------
 lib/jiff-client.js                       |  34 ++++++
 2 files changed, 102 insertions(+), 64 deletions(-)

diff --git a/lib/ext/jiff-client-asynchronousshare.js b/lib/ext/jiff-client-asynchronousshare.js
index db30e7515..20ea5c4aa 100644
--- a/lib/ext/jiff-client-asynchronousshare.js
+++ b/lib/ext/jiff-client-asynchronousshare.js
@@ -121,17 +121,17 @@
       return share.isadd(share.jiff.server_generate_and_share({number: 0}, share.holders, share.threshold, share.Zp, op_id, share.ratios)[0]);
     }
 
-    /** Creates a clone of the share with same properties (holders, threshold, etc.)
+    /** Secret Share Clone
+     * @method clone
+     * @memberof SecretShare
+     * @instance
+     * @param {boolean} ready - whether the value of the share is ready or deferred.
+     * @param {promise} promise - a promise to the value of the share.
+     * @param {number} value - the value of the share (null if not ready).
+     * @return {SecretShare} - clone of share with changed value/promise
      */
-    share.secret_clone = function(ready, promise, value, threshold, holders, Zp, id, ratios) {
-      var threshold = threshold == undefined ? share.threshold : threshold;
-      var holders = holders == undefined ? share.holders : holders;
-      var Zp = Zp == undefined ? share.Zp : Zp;
-      var id = id == undefined ? null : id;
-      var ratios = ratios == undefined ? share.ratios : ratios;
-
-      var clone = jiff.secret_share(share.jiff, ready, promise, value, holders, threshold, Zp, id, ratios);
-      return clone;
+    share.clone = function (ready, promise, value) {
+      return share.jiff.secret_share(share.jiff, ready, promise, value, share.holders, share.threshold, share.Zp, null, share.ratios);
     };
 
     share.cadd = function (o) {
@@ -148,20 +148,17 @@
       };
 
       if (share.ready) {
-        return share.secret_clone(true, null, ready_add());
+        return share.clone(true, null, ready_add());
       }
 
       var promise = share.promise.then(function () {
         return ready_add();
       }, share.error);
-      return share.secret_clone(false, promise, null);
+      return share.clone(false, promise, null);
     };
 
     share.sadd = function (o) {
-      (share.jiff.helpers.shares_compatible(share, o));
-      if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
-        throw new Error('shares must have the same ratios');
-      }
+      share.jiff.helpers.shares_compatible(share, o);
 
       // add the two share when ready
       var ready_add = function () {
@@ -173,13 +170,17 @@
       };
 
       if (share.ready && o.ready) {
-        return share.secret_clone(true, null, ready_add(), max(share.threshold, o.threshold));
+        var clone = share.clone(true, null, ready_add());
+        clone.threshold = max(share.threshold, o.threshold);
+        return clone;
       }
 
       var promise = share.pick_promise(o).then( function () {
         return ready_add();
       }, share.error);
-      return share.secret_clone(false, promise, null, max(share.threshold, o.threshold));
+      var clone = share.clone(false, promise, null);
+      clone.threshold = max(share.threshold, o.threshold);
+      return clone;
     };
 
     share.csub = function (o) {
@@ -196,20 +197,17 @@
       };
 
       if (share.ready) {
-        return share.secret_clone(true, null, ready_sub());
+        return share.clone(true, null, ready_sub());
       }
 
       var promise = share.promise.then(function () {
         return ready_sub();
       }, share.error);
-      return share.secret_clone(false, promise, null);
+      return share.clone(false, promise, null);
     };
 
     share.ssub = function (o) {
-      (share.jiff.helpers.shares_compatible(share, o));
-      if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
-        throw new Error('shares must have the same ratios');
-      }
+      share.jiff.helpers.shares_compatible(share, o);
 
       var ready_sub = function () {
         var result = [];
@@ -220,14 +218,18 @@
       };
 
       if (share.ready && o.ready) {
-        return share.secret_clone(true, null, ready_sub(), max(share.threshold, o.threshold));
+        var clone = share.clone(true, null, ready_sub());
+        clone.threshold = max(share.threshold, o.threshold);
+        return clone;
       }
 
       // promise to execute ready_add when both are ready
       var promise = share.pick_promise(o).then(function () {
         return ready_sub();
       }, share.error);
-      return share.secret_clone(false, promise, null, max(share.threshold, o.threshold));
+      var clone = share.clone(false, promise, null);
+      clone.threshold = max(share.threshold, o.threshold);
+      return clone;
     };
 
     share.cmult = function (o) {
@@ -244,20 +246,17 @@
       };
 
       if (share.ready) {
-        return share.secret_clone(true, null, ready_mult());
+        return share.clone(true, null, ready_mult());
       }
 
       var promise = share.promise.then(function () {
         return ready_mult();
       }, share.error);
-      return share.secret_clone(false, promise, null);
+      return share.clone(false, promise, null);
     };
 
     share.smult = function (o, op_id) {
-      (share.jiff.helpers.shares_compatible(share, o));
-      if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
-        throw new Error('shares must have the same ratios');
-      }
+      share.jiff.helpers.shares_compatible(share, o);
 
       if (op_id == null) {
         op_id = share.jiff.counters.gen_op_id('*', share.holders);
@@ -265,7 +264,9 @@
 
       var final_deferred = $.Deferred();
       var final_promise = final_deferred.promise();
-      var result = share.secret_clone(false, final_promise, undefined, max(share.threshold, o.threshold), undefined, undefined, 'share:' + op_id);
+      var result = share.clone(false, final_promise, null);
+      result.threshold = max(share.threshold, o.threshold);
+      result.id = 'share' + op_id;
 
       // Get shares of triplets.
       var triplet = jiff.triplet(share.holders, max(share.threshold, o.threshold), share.Zp, op_id + ':triplet', share.ratios);
@@ -304,13 +305,10 @@
     };
 
     share.smult_bgw = function(o, op_id) {
-      (share.jiff.helpers.shares_compatible(share, o));
+      share.jiff.helpers.shares_compatible(share, o);
       if ((share.threshold - 1) + (o.threshold - 1) > share.holders.length - 1) {
         throw new Error('threshold too high for BGW (*)');
       }
-      if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
-        throw new Error('shares must have the same ratios');
-      }
 
       var final_deferred = $.Deferred();
       var final_promise = final_deferred.promise();
@@ -320,8 +318,8 @@
         var promises = [];
 
         for (var i = 0; i < share.value.length; i++) {
-          var share_tmp = share.secret_clone(true, null, share.value[i]);
-          var o_tmp = o.secret_clone(true, null, o.value[i]);
+          var share_tmp = share.clone(true, null, share.value[i]);
+          var o_tmp = o.clone(true, null, o.value[i]);
           var multshare = share_tmp.legacy.smult_bgw(o_tmp, op_id);
           promises.push(multshare.promise);
 
@@ -337,14 +335,18 @@
 
       if (share.ready && o.ready) {
         ready_mult_bgw();
-        return share.secret_clone(false, final_promise, undefined, max(share.threshold, o.threshold));
+        var clone = share.clone(false, final_promise, null);
+        clone.threshold = max(share.threshold, o.threshold);
+        return clone;
       }
 
       // promise to execute ready_add when both are ready
       share.pick_promise(o).then( function () {
         ready_mult_bgw();
       }, share.error);
-      return share.secret_clone(false, final_promise, undefined, max(share.threshold, o.threshold));
+      var clone = share.clone(false, final_promise, null);
+      clone.threshold = max(share.threshold, o.threshold);
+      return clone;
     };
 
     share.cdiv = function (o, op_id) {
@@ -367,7 +369,10 @@
       // Allocate share for result to which the answer will be resolved once available
       var final_deferred = $.Deferred();
       var final_promise = final_deferred.promise();
-      var result = share.secret_clone(false, final_promise, undefined, max(share.threshold, o.threshold), undefined, undefined,'share:' + op_id);
+      var clone = share.clone(false, final_promise, null);
+      clone.threshold = max(share.threshold, o.threshold);
+      clone.id = 'share' + op_id;
+      return clone;
 
       var ZpOVERc = share_helpers['floor/'](share.Zp, o);
 
@@ -420,19 +425,18 @@
 
       if (share.ready) {
         // If share is ready.
-        return share.secret_clone(true, null, ready_cdivfac());
+        return share.clone(true, null, ready_cdivfac());
       }
 
       var promise = share.promise.then(function () {
         return ready_cdivfac();
       }, share.error);
-      return share.secret_clone(false, promise, undefined);
+      return share.clone(false, promise, undefined);
     };
 
     share.sdiv = function (o, l, op_id) {
-      if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
-        throw new Error('shares must have the same ratios');
-      }
+      // check that shares are compatible to compute
+      share.jiff.helpers.shares_compatible(share, o);
       var final_deferred = $.Deferred();
       var final_promise = final_deferred.promise();
 
@@ -441,8 +445,8 @@
         var promises = [];
 
         for (var i = 0; i < share.value.length; i++) {
-          var share_tmp = share.secret_clone(true, null, share.value[i]);
-          var o_tmp = o.secret_clone(true, null, o.value[i]);
+          var share_tmp = share.clone(true, null, share.value[i]);
+          var o_tmp = o.clone(true, null, o.value[i]);
           var divshare = share_tmp.legacy.sdiv(o_tmp, l, op_id + ':' + i);
           promises.push(divshare.promise);
 
@@ -459,20 +463,23 @@
 
       if (share.ready && o.ready) {
         ready_div();
-        return share.secret_clone(false, final_promise, undefined, max(share.threshold, o.threshold));
+        var clone = share.clone(false, final_promise, null);
+        clone.threshold = max(share.threshold, o.threshold);
+        return clone;
       }
 
       // promise to execute ready_add when both are ready
       share.pick_promise(o).then( function () {
         ready_div();
       }, share.error);
-      return share.secret_clone(false, final_promise, undefined, max(share.threshold, o.threshold));
+      var clone = share.clone(false, final_promise, null);
+      clone.threshold = max(share.threshold, o.threshold);
+      return clone;
     };
 
     share.smod = function (o, l, op_id) {
-      if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
-        throw new Error('shares must have the same ratios');
-      }
+      // check that shares are compatible to compute
+      share.jiff.helpers.shares_compatible(share, o);
       var result, modshare;
 
       var ready_mod = function () {
@@ -529,7 +536,8 @@
 
       var final_deferred = $.Deferred();
       var final_promise = final_deferred.promise();
-      var result = share.secret_clone(false, final_promise, undefined, undefined, undefined, undefined, 'share:' + op_id);
+      var result = share.clone(false, final_promise, null);
+      result.id = 'share' + op_id;
 
       // if 2*self is even, then self is less than half prime, otherwise self is greater or equal to half prime
       var share2 = share.icmult(2);
@@ -613,15 +621,11 @@
      * @param {SecretShare} s2 - second share
      * @return {boolean} true if shares are compatible, false otherwise.
      */
-    jiff.helpers.shares_compatible = function (s1, s2){
-      if (!(s2.jiff === s1.jiff)) {
-        throw new Error('shares do not belong to the same instance (+)');
-      }
-      if (!jiff.helpers.Zp_equals(s1, s2)) {
-        throw new Error('shares must belong to the same field (Zp)');
-      }
-      if (!jiff.helpers.array_equals(s1.holders, s2.holders)) {
-        throw new Error('shares must be held by the same parties');
+    var old_shares_compatible = jiff.helpers.are_shares_compatible;
+    jiff.helpers.are_shares_compatible = function (s1, s2){
+      old_shares_compatible(s1, s2);
+      if (!jiff.helpers.ratios_equals(s1.ratios, s2.ratios)) {
+        throw new Error('share must have the same ratios');
       }
     };
 
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index a9201d37e..2b7c901b5 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -1622,6 +1622,19 @@
       return self.jiff.open(self, parties, op_ids);
     };
 
+    /** Secret Share Clone
+     * @method clone
+     * @memberof SecretShare
+     * @instance
+     * @param {boolean} ready - whether the value of the share is ready or deferred.
+     * @param {promise} promise - a promise to the value of the share.
+     * @param {number} value - the value of the share (null if not ready).
+     * @return {SecretShare} - clone of share with changed value/promise
+     */
+    self.clone = function (ready, promise, value) {
+      return self.jiff.secret_share(self.jiff, ready, promise, value, self.holders, self.threshold, self.Zp, null);
+    };
+
     /**
      * Generic Addition.
      * Uses either the constant or secret version of this operator depending on type of paramter.
@@ -3904,6 +3917,27 @@
       return s1.Zp === s2.Zp;
     };
 
+    /**
+     * Check that two shares are compatible
+     * @method are_shares_compatible
+     * @memberof jiff-instance.helpers
+     * @instance
+     * @param {SecretShare} s1 - first share
+     * @param {SecretShare} s2 - second share
+     * @return {boolean} true if shares are compatible, false otherwise.
+     */
+    jiff.helpers.are_shares_compatible = function (s1, s2){
+      if (!(s2.jiff === s1.jiff)) {
+        throw new Error('shares do not belong to the same instance (+)');
+      }
+      if (!jiff.helpers.Zp_equals(s1, s2)) {
+        throw new Error('shares must belong to the same field (Zp)');
+      }
+      if (!jiff.helpers.array_equals(s1.holders, s2.holders)) {
+        throw new Error('shares must be held by the same parties');
+      }
+    };
+
     /**
      * Generate a random integer between 0 and max-1 [inclusive].
      * Modify this to change the source of randomness and how it is generated.

From fd930d88b62164d5fe022e2df43e170b8f7118ca Mon Sep 17 00:00:00 2001
From: sashni <sashni@bu.edu>
Date: Tue, 6 Aug 2019 12:10:13 -0400
Subject: [PATCH 24/24] use clone in all primitives

---
 lib/ext/jiff-client-asynchronousshare.js | 140 ++++-------------------
 lib/ext/jiff-server-asyncshare.js        |  33 +-----
 lib/jiff-client.js                       |  68 ++++++-----
 3 files changed, 59 insertions(+), 182 deletions(-)

diff --git a/lib/ext/jiff-client-asynchronousshare.js b/lib/ext/jiff-client-asynchronousshare.js
index 20ea5c4aa..68d46a39d 100644
--- a/lib/ext/jiff-client-asynchronousshare.js
+++ b/lib/ext/jiff-client-asynchronousshare.js
@@ -130,8 +130,8 @@
      * @param {number} value - the value of the share (null if not ready).
      * @return {SecretShare} - clone of share with changed value/promise
      */
-    share.clone = function (ready, promise, value) {
-      return share.jiff.secret_share(share.jiff, ready, promise, value, share.holders, share.threshold, share.Zp, null, share.ratios);
+    share.clone = function (ready, promise, value, threshold, id) {
+      return share.jiff.secret_share(share.jiff, ready, promise, value, share.holders, threshold, share.Zp, id, share.ratios);
     };
 
     share.cadd = function (o) {
@@ -158,7 +158,7 @@
     };
 
     share.sadd = function (o) {
-      share.jiff.helpers.shares_compatible(share, o);
+      share.jiff.helpers.are_shares_compatible(share, o);
 
       // add the two share when ready
       var ready_add = function () {
@@ -170,17 +170,13 @@
       };
 
       if (share.ready && o.ready) {
-        var clone = share.clone(true, null, ready_add());
-        clone.threshold = max(share.threshold, o.threshold);
-        return clone;
+        return share.clone(true, null, ready_add(), max(share.threshold, o.threshold));
       }
 
       var promise = share.pick_promise(o).then( function () {
         return ready_add();
       }, share.error);
-      var clone = share.clone(false, promise, null);
-      clone.threshold = max(share.threshold, o.threshold);
-      return clone;
+      return share.clone(false, promise, null, max(share.threshold, o.threshold));
     };
 
     share.csub = function (o) {
@@ -207,7 +203,7 @@
     };
 
     share.ssub = function (o) {
-      share.jiff.helpers.shares_compatible(share, o);
+      share.jiff.helpers.are_shares_compatible(share, o);
 
       var ready_sub = function () {
         var result = [];
@@ -218,18 +214,14 @@
       };
 
       if (share.ready && o.ready) {
-        var clone = share.clone(true, null, ready_sub());
-        clone.threshold = max(share.threshold, o.threshold);
-        return clone;
+        return share.clone(true, null, ready_sub(), max(share.threshold, o.threshold));
       }
 
       // promise to execute ready_add when both are ready
       var promise = share.pick_promise(o).then(function () {
         return ready_sub();
       }, share.error);
-      var clone = share.clone(false, promise, null);
-      clone.threshold = max(share.threshold, o.threshold);
-      return clone;
+      return share.clone(false, promise, null, max(share.threshold, o.threshold));
     };
 
     share.cmult = function (o) {
@@ -256,7 +248,7 @@
     };
 
     share.smult = function (o, op_id) {
-      share.jiff.helpers.shares_compatible(share, o);
+      share.jiff.helpers.are_shares_compatible(share, o);
 
       if (op_id == null) {
         op_id = share.jiff.counters.gen_op_id('*', share.holders);
@@ -264,9 +256,7 @@
 
       var final_deferred = $.Deferred();
       var final_promise = final_deferred.promise();
-      var result = share.clone(false, final_promise, null);
-      result.threshold = max(share.threshold, o.threshold);
-      result.id = 'share' + op_id;
+      var result = share.clone(false, final_promise, null, max(share.threshold, o.threshold), 'share'+op_id);
 
       // Get shares of triplets.
       var triplet = jiff.triplet(share.holders, max(share.threshold, o.threshold), share.Zp, op_id + ':triplet', share.ratios);
@@ -305,7 +295,7 @@
     };
 
     share.smult_bgw = function(o, op_id) {
-      share.jiff.helpers.shares_compatible(share, o);
+      share.jiff.helpers.are_shares_compatible(share, o);
       if ((share.threshold - 1) + (o.threshold - 1) > share.holders.length - 1) {
         throw new Error('threshold too high for BGW (*)');
       }
@@ -335,18 +325,14 @@
 
       if (share.ready && o.ready) {
         ready_mult_bgw();
-        var clone = share.clone(false, final_promise, null);
-        clone.threshold = max(share.threshold, o.threshold);
-        return clone;
+        return share.clone(false, final_promise, null, max(share.threshold, o.threshold));
       }
 
       // promise to execute ready_add when both are ready
       share.pick_promise(o).then( function () {
         ready_mult_bgw();
       }, share.error);
-      var clone = share.clone(false, final_promise, null);
-      clone.threshold = max(share.threshold, o.threshold);
-      return clone;
+      return share.clone(false, final_promise, null, max(share.threshold, o.threshold));
     };
 
     share.cdiv = function (o, op_id) {
@@ -369,10 +355,7 @@
       // Allocate share for result to which the answer will be resolved once available
       var final_deferred = $.Deferred();
       var final_promise = final_deferred.promise();
-      var clone = share.clone(false, final_promise, null);
-      clone.threshold = max(share.threshold, o.threshold);
-      clone.id = 'share' + op_id;
-      return clone;
+      var result = share.clone(false, final_promise, null, max(share.threshold, o.threshold), 'share'+op_id);
 
       var ZpOVERc = share_helpers['floor/'](share.Zp, o);
 
@@ -436,7 +419,7 @@
 
     share.sdiv = function (o, l, op_id) {
       // check that shares are compatible to compute
-      share.jiff.helpers.shares_compatible(share, o);
+      share.jiff.helpers.are_shares_compatible(share, o);
       var final_deferred = $.Deferred();
       var final_promise = final_deferred.promise();
 
@@ -479,7 +462,7 @@
 
     share.smod = function (o, l, op_id) {
       // check that shares are compatible to compute
-      share.jiff.helpers.shares_compatible(share, o);
+      share.jiff.helpers.are_shares_compatible(share, o);
       var result, modshare;
 
       var ready_mod = function () {
@@ -536,8 +519,7 @@
 
       var final_deferred = $.Deferred();
       var final_promise = final_deferred.promise();
-      var result = share.clone(false, final_promise, null);
-      result.id = 'share' + op_id;
+      var result = share.clone(false, final_promise, null, share.threshold, 'share'+op_id);
 
       // if 2*self is even, then self is less than half prime, otherwise self is greater or equal to half prime
       var share2 = share.icmult(2);
@@ -556,7 +538,6 @@
       // open share + noise, and utilize opened value with shared bit representation of noise to check the least significant digit of share.
       share2.jiff.internal_open(r.isadd(share2), share2.holders, op_id + ':open').then(function (result) {
         var wrapped = share.jiff.protocols.bits.cgt(bits, result, op_id + ':bits.cgt');
-        wrapped.ratios = share.ratios;
         var isOdd = share.jiff.helpers.mod(result, 2);
         isOdd = bits[0].icxor_bit(isOdd);
         isOdd = isOdd.isxor_bit(wrapped, op_id + ':sxor_bit');
@@ -568,27 +549,6 @@
       return result;
     };
 
-    share.clt = function (o, op_id) {
-      var result = share.legacy.clt(o, op_id);
-      result.ratios = share.ratios;
-      return result;
-    }
-
-    share.slt = function (o, op_id) {
-      if (!share.jiff.helpers.ratios_equals(share.ratios, o.ratios)) {
-        throw new Error('shares must have the same ratios');
-      }
-      var result = share.legacy.slt(o, op_id);
-      result.ratios = share.ratios;
-      return result;
-    }
-
-    share.cgt = function (o, op_id) {
-      var result = share.legacy.cgt(o, op_id);
-      result.ratios = share.ratios;
-      return result;
-    }
-
     share.isadd = share.sadd;
     share.issub = share.ssub;
     share.ismult = share.smult;
@@ -596,9 +556,6 @@
     share.icsub = share.csub;
     share.icmult = share.cmult;
     share.ilt_halfprime = share.lt_halfprime;
-    share.islt = share.slt;
-    share.iclt = share.clt;
-    share.icgt = share.cgt;
 
     return share;
   }
@@ -661,11 +618,9 @@
     };
 
     var old_secret_share = jiff.secret_share;
-    jiff.secret_share = function (jiff, ready, promise, value, holders, threshold, Zp, id, ratios) {
+    jiff.secret_share = function (jiff, ready, promise, value, holders, threshold, Zp, id) {
       var share = old_secret_share(jiff, ready, promise, value, holders, threshold, Zp, id);
-      if (!(ratios == null)) {
-        share.ratios = ratios;
-      }
+      share.ratios = arguments[8].length > 0 ? arguments[8][0] : arguments[8];
       return share;
     };
 
@@ -992,7 +947,7 @@
     };
 
     /**
-     * Same as jiff-instance.share, but used by internal JIFF primitives/protocols (bgw).
+     * Same as jiff-instance.share, but used by internal JIFF primitives/protocols.
      */
     jiff.internal_share = function (secret, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios) {
       return jiff_share(jiff, secret, threshold, receivers_list, senders_list, Zp, share_id, receivers_ratios);
@@ -1048,61 +1003,6 @@
       return jiff_triplet(jiff, receivers_list, threshold, Zp, triplet_id, receivers_ratios);
     };
 
-    jiff_server_share_number = function (jiff, options, receivers_list, threshold, Zp, number_id, ratios) {
-      if (Zp == null) {
-        Zp = jiff.Zp;
-      }
-      if (receivers_list == null) {
-        receivers_list = [];
-        for (var i = 1; i <= jiff.party_count; i++) {
-          receivers_list.push(i);
-        }
-      }
-      if (threshold == null) {
-        threshold = receivers_list.length;
-      }
-
-      // Get the id of the number.
-      if (number_id == null) {
-        number_id = jiff.counters.gen_number_id(receivers_list);
-      }
-
-      if (options == null) {
-        options = {};
-      }
-      if (options.count == null) {
-        options.count = 1;
-      }
-
-      var msg = {number_id: number_id, receivers: receivers_list, threshold: threshold, Zp: Zp, ratios: ratios};
-      msg = Object.assign(msg, options);
-
-      msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'number', msg], 2);
-      msg = JSON.stringify(msg);
-
-      // Setup deferreds to handle receiving the triplets later.
-      var shares = [];
-      for (i = 0; i < options.count; i++) {
-        var deferred = $.Deferred();
-        jiff.deferreds[number_id + ':' + i] = deferred;
-        shares[i] = jiff.secret_share(jiff, false, deferred.promise(), undefined, receivers_list, threshold, Zp, number_id + ':' + i, ratios);
-      }
-
-      // Send a request to the server.
-      if (jiff.id === 's1') {
-        jiff.socket.safe_emit('number', msg);
-      } else {
-        var cipher = jiff.hooks.encryptSign(jiff, msg, jiff.keymap['s1'], jiff.secret_key);
-        jiff.socket.safe_emit('number', JSON.stringify(cipher));
-      }
-
-      return shares;
-    }
-
-    jiff.server_generate_and_share = function (options, receivers_list, threshold, Zp, number_id, ratios) {
-      return jiff_server_share_number(jiff, options, receivers_list, threshold, Zp, number_id, ratios);
-    };
-
     // Change set up of receiving matching shares to call correct receive_share function
     jiff.socket.off('share');
     jiff.socket.on('share', function (msg, callback) {
diff --git a/lib/ext/jiff-server-asyncshare.js b/lib/ext/jiff-server-asyncshare.js
index 024dff9f3..c23efbe7a 100644
--- a/lib/ext/jiff-server-asyncshare.js
+++ b/lib/ext/jiff-server-asyncshare.js
@@ -20,35 +20,6 @@ exports.make_jiff = function (base_instance, options) {
     return parseInt(party_id, 10) + (share_num * (party_count+1));
   };
 
-  jiff.triplet = function (computation_id, from_id, msg) {
-    // decrypt and verify signature
-    try {
-      msg = jiff.hooks.decryptSign(jiff, msg, jiff.secret_key_map[computation_id], jiff.key_map[computation_id][from_id]);
-      msg = JSON.parse(msg);
-    } catch (error) { // invalid signature
-      console.log('error decrypting message');
-      jiff.hooks.log(jiff, 'Error in triplet from ' + computation_id + '-' + from_id + ': ' + error);
-      return { success: false, error: 'invalid signature'};
-    }
-
-    try {
-      msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'triplet', computation_id, from_id, msg], 4);
-    } catch (err) {
-      return { success: false, error: typeof(err) === 'string' ? err : err.message };
-    }
-
-    // request/generate triplet share.
-    var triplet_msg = jiff.request_triplet_share(msg, computation_id, from_id);
-
-    //{triplet: all_triplets[triplet_id][from_id], triplet_id: triplet_id};
-    triplet_msg = jiff.execute_array_hooks('afterOperation', [jiff, 'triplet', computation_id, from_id, triplet_msg], 4);
-    triplet_msg = JSON.stringify(triplet_msg);
-
-    // encrypt an sign message then send it.
-    var pkey = jiff.key_map[computation_id][from_id];
-    triplet_msg = jiff.hooks.encryptSign(jiff, triplet_msg, pkey, jiff.secret_key_map[computation_id]);
-    return { success: true, message: triplet_msg };
-  };
 
   // Helpers for creating triplets/numbers and sharing them.
   jiff.request_triplet_share = function (msg, computation_id, from_id) {
@@ -100,7 +71,7 @@ exports.make_jiff = function (base_instance, options) {
     var threshold = msg.threshold;
     var Zp = msg.Zp;
     var count = msg.count;
-    var ratios = msg.ratios;
+    var ratios = msg.__args[0];
 
     if (count == null) {
       count = 1;
@@ -140,4 +111,4 @@ function initialize_hooks(jiff, options) {
   } else {
     jiff.hooks.computeShares = options.hooks.computeShares;
   }
-}
\ No newline at end of file
+}
diff --git a/lib/jiff-client.js b/lib/jiff-client.js
index 2b7c901b5..a456ace5e 100644
--- a/lib/jiff-client.js
+++ b/lib/jiff-client.js
@@ -821,6 +821,8 @@
    * @return {SecretShare[]} - this party's share of the generated number.
    */
   function jiff_server_share_number(jiff, options, receivers_list, threshold, Zp, number_id) {
+    var __args = arguments[6];
+
     if (Zp == null) {
       Zp = jiff.Zp;
     }
@@ -846,7 +848,7 @@
       options.count = 1;
     }
 
-    var msg = {number_id: number_id, receivers: receivers_list, threshold: threshold, Zp: Zp};
+    var msg = {number_id: number_id, receivers: receivers_list, threshold: threshold, Zp: Zp, __args: __args};
     msg = Object.assign(msg, options);
 
     msg = jiff.execute_array_hooks('beforeOperation', [jiff, 'number', msg], 2);
@@ -857,7 +859,7 @@
     for (i = 0; i < options.count; i++) {
       var deferred = new Deferred();
       jiff.deferreds[number_id + ':' + i] = deferred;
-      shares[i] = jiff.secret_share(jiff, false, deferred.promise, undefined, receivers_list, threshold, Zp, number_id + ':' + i);
+      shares[i] = jiff.secret_share(jiff, false, deferred.promise, undefined, receivers_list, threshold, Zp, number_id + ':' + i, __args[0]);
     }
 
     // Send a request to the server.
@@ -1631,8 +1633,8 @@
      * @param {number} value - the value of the share (null if not ready).
      * @return {SecretShare} - clone of share with changed value/promise
      */
-    self.clone = function (ready, promise, value) {
-      return self.jiff.secret_share(self.jiff, ready, promise, value, self.holders, self.threshold, self.Zp, null);
+    self.clone = function (ready, promise, value, threshold, id) {
+      return self.jiff.secret_share(self.jiff, ready, promise, value, self.holders, threshold, self.Zp, id);
     };
 
     /**
@@ -1889,13 +1891,13 @@
 
       if (self.ready) {
         // if share is ready
-        return self.jiff.secret_share(self.jiff, true, null, self.jiff.helpers.mod(share_helpers['+'](self.value, cst), self.Zp), self.holders, self.threshold, self.Zp);
+        return self.clone(true, null, self.jiff.helpers.mod(share_helpers['+'](self.value, cst), self.Zp), self.threshold);
       }
 
       var promise = self.promise.then(function () {
         return self.jiff.helpers.mod(share_helpers['+'](self.value, cst), self.Zp);
       }, self.error);
-      return self.jiff.secret_share(self.jiff, false, promise, undefined, self.holders, self.threshold, self.Zp);
+      return self.clone(false, promise, undefined, self.threshold);
     };
 
     /**
@@ -1913,13 +1915,13 @@
 
       if (self.ready) {
         // if share is ready
-        return self.jiff.secret_share(self.jiff, true, null, self.jiff.helpers.mod(share_helpers['-'](self.value, cst), self.Zp), self.holders, self.threshold, self.Zp);
+        return self.clone(true, null, self.jiff.helpers.mod(share_helpers['-'](self.value, cst), self.Zp), self.threshold);
       }
 
       var promise = self.promise.then(function () {
         return self.jiff.helpers.mod(share_helpers['-'](self.value, cst), self.Zp);
       }, self.error);
-      return self.jiff.secret_share(self.jiff, false, promise, undefined, self.holders, self.threshold, self.Zp);
+      return self.clone(false, promise, undefined, self.threshold);
     };
 
     /**
@@ -1937,13 +1939,13 @@
 
       if (self.ready) {
         // if share is ready
-        return self.jiff.secret_share(self.jiff, true, null, self.jiff.helpers.mod(share_helpers['*'](self.value, cst), self.Zp), self.holders, self.threshold, self.Zp);
+        return self.clone(true, null, self.jiff.helpers.mod(share_helpers['*'](self.value, cst), self.Zp), self.threshold);
       }
 
       var promise = self.promise.then(function () {
         return self.jiff.helpers.mod(share_helpers['*'](self.value, cst), self.Zp);
       }, self.error);
-      return self.jiff.secret_share(self.jiff, false, promise, undefined, self.holders, self.threshold, self.Zp);
+      return self.clone(false, promise, undefined, self.threshold);
     };
 
     /**
@@ -1963,13 +1965,13 @@
 
       if (self.ready) {
         // If share is ready.
-        return self.jiff.secret_share(self.jiff, true, null, self.jiff.helpers.mod(share_helpers['*'](self.value, inv), self.Zp), self.holders, self.threshold, self.Zp);
+        return self.clone(true, null, self.jiff.helpers.mod(share_helpers['+'](self.value, inv), self.Zp), self.threshold);
       }
 
       var promise = self.promise.then(function () {
         return self.jiff.helpers.mod(share_helpers['*'](self.value, inv), self.Zp);
       }, self.error);
-      return self.jiff.secret_share(self.jiff, false, promise, undefined, self.holders, self.threshold, self.Zp);
+      return self.clone(false, promise, undefined, self.threshold);
     };
 
     /**
@@ -1998,12 +2000,12 @@
 
       if (self.ready && o.ready) {
         // both shares are ready
-        return self.jiff.secret_share(self.jiff, true, null, ready_add(), self.holders, max(self.threshold, o.threshold), self.Zp);
+        return self.clone(true, null, ready_add(), max(self.threshold, o.threshold));
       }
 
       // promise to execute ready_add when both are ready
       var promise = self.pick_promise(o).then(ready_add, self.error);
-      return self.jiff.secret_share(self.jiff, false, promise, undefined, self.holders, max(self.threshold, o.threshold), self.Zp);
+      return self.clone(false, promise, undefined, max(self.threshold, o.threshold));
     };
 
     /**
@@ -2032,12 +2034,12 @@
 
       if (self.ready && o.ready) {
         // both shares are ready
-        return self.jiff.secret_share(self.jiff, true, null, ready_sub(), self.holders, max(self.threshold, o.threshold), self.Zp);
+        return self.clone(true, null, ready_sub(), max(self.threshold, o.threshold));
       }
 
       // promise to execute ready_add when both are ready
       var promise = self.pick_promise(o).then(ready_sub, self.error);
-      return self.jiff.secret_share(self.jiff, false, promise, undefined, self.holders, max(self.threshold, o.threshold), self.Zp);
+      return self.clone(false, promise, undefined, max(self.threshold, o.threshold));
     };
 
     /**
@@ -2070,7 +2072,7 @@
 
       var final_deferred = new Deferred();
       var final_promise = final_deferred.promise;
-      var result = self.jiff.secret_share(self.jiff, false, final_promise, undefined, self.holders, max(self.threshold, o.threshold), self.Zp, 'share:' + op_id);
+      var result = self.clone(false, final_promise, undefined, max(self.threshold, o.threshold), 'share:' + op_id);
 
       // Get shares of triplets.
       var triplet = jiff.triplet(self.holders, max(self.threshold, o.threshold), self.Zp, op_id + ':triplet');
@@ -2141,7 +2143,7 @@
 
       var final_deferred = new Deferred();
       var final_promise = final_deferred.promise;
-      var result = self.jiff.secret_share(self.jiff, false, final_promise, undefined, self.holders, max(self.threshold, o.threshold), self.Zp, 'share:' + op_id);
+      var result = self.clone(false, final_promise, undefined, max(self.threshold, o.threshold), 'share:' + op_id);
 
       Promise.all([self.promise, o.promise]).then(
         function () {
@@ -2173,7 +2175,7 @@
 
       var final_deferred = new Deferred();
       var final_promise = final_deferred.promise;
-      var result = self.jiff.secret_share(self.jiff, false, final_promise, undefined, self.holders, threshold, self.Zp, 'share:' + op_id);
+      var result = self.clone(false, final_promise, undefined, threshold, 'share:' + op_id);
 
       self.wThen(function () {
         var intermediate_shares = self.jiff.internal_share(self.value, threshold, self.holders, self.holders, self.Zp, op_id);
@@ -2407,7 +2409,7 @@
 
       var final_deferred = new Deferred();
       var final_promise = final_deferred.promise;
-      var result = self.jiff.secret_share(self.jiff, false, final_promise, undefined, self.holders, max(self.threshold, o.threshold), self.Zp, 'share:' + op_id);
+      var result = self.clone(false, final_promise, undefined, max(self.threshold, o.threshold), 'share:' + op_id);
 
       var w = self.ilt_halfprime(op_id + ':halfprime:1');
       Promise.all([w.promise]).then(function () {
@@ -2471,7 +2473,7 @@
 
       var final_deferred = new Deferred();
       var final_promise = final_deferred.promise;
-      var result = self.jiff.secret_share(self.jiff, false, final_promise, undefined, self.holders, self.threshold, self.Zp, 'share:' + op_id);
+      var result = self.clone(false, final_promise, undefined, self.threshold, 'share:' + op_id);
 
       var w = share_helpers['<'](cst, share_helpers['/'](self.Zp, 2)) ? 1 : 0;
       var x = self.ilt_halfprime(op_id + ':halfprime:1');
@@ -2532,7 +2534,7 @@
 
       var final_deferred = new Deferred();
       var final_promise = final_deferred.promise;
-      var result = self.jiff.secret_share(self.jiff, false, final_promise, undefined, self.holders, self.threshold, self.Zp, 'share:' + op_id);
+      var result = self.clone(false, final_promise, undefined, self.threshold, 'share:' + op_id);
 
       var w = self.ilt_halfprime(op_id + ':halfprime:1');
       Promise.all([w.promise]).then(function () {
@@ -2729,7 +2731,7 @@
       // Allocate share for result to which the answer will be resolved once available
       var final_deferred = new Deferred();
       var final_promise = final_deferred.promise;
-      var result = self.jiff.secret_share(self.jiff, false, final_promise, undefined, self.holders, self.threshold, self.Zp, 'share:' + op_id);
+      var result = self.clone(false, final_promise, undefined, self.threshold, 'share:' + op_id);
 
       var ZpOVERc = share_helpers['floor/'](self.Zp, cst);
 
@@ -2826,7 +2828,7 @@
 
       var final_deferred = new Deferred();
       var final_promise = final_deferred.promise;
-      var result = self.jiff.secret_share(self.jiff, false, final_promise, undefined, self.holders, self.threshold, self.Zp, 'share:' + op_id);
+      var result = self.clone(false, final_promise, undefined, self.threshold, 'share:' + op_id);
 
       // if 2*self is even, then self is less than half prime, otherwise self is greater or equal to half prime
       var share = self.icmult(2);
@@ -4402,7 +4404,11 @@
      * @returns {SecretShare[]} an array of secret shares of shares of zeros / random bits / random numbers / random non-zero numbers according to options.
      */
     jiff.server_generate_and_share = function (options, receivers_list, threshold, Zp, number_id) {
-      return jiff_server_share_number(jiff, options, receivers_list, threshold, Zp, number_id);
+      var __args = [];
+      for (var i = 5; i < arguments.length; i++) {
+        __args.push(arguments[i]);
+      }
+      return jiff_server_share_number(jiff, options, receivers_list, threshold, Zp, number_id, __args);
     };
 
     /**
@@ -4880,7 +4886,7 @@
 
       // initialize result
       var deferred = new Deferred();
-      var result = jiff.secret_share(jiff, false, deferred.promise, undefined, bits[0].holders, bits[0].threshold, bits[0].Zp, 'share:' + op_id);
+      var result = bits[0].clone(false, deferred.promise, undefined, bits[0].threshold, 'share'+op_id);
 
       // Subtract bits2 from bits1, only keeping track of borrow
       var borrow = bits[0].inot().icmult(constant_bits[0]);
@@ -5401,7 +5407,7 @@
       final_deferred.promise.then(resolve_many_secrets.bind(null, deferreds));
 
       // get useless share of zero (just for padding)
-      var zero = jiff.secret_share(jiff, true, null, 0, bits[0].holders, 1, bits[0].Zp, 'share:' + op_id + ':zero_share');
+      var zero = bits[0].clone(true, null, 0, 1, 'share' + op_id + 'zero_share');
       var initial = [ zero ];
 
       // special case
@@ -5545,7 +5551,7 @@
 
       // initialize result
       var deferred = new Deferred();
-      var result = jiff.secret_share(jiff, false, deferred.promise, undefined, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, 'share:' + op_id);
+      var result = bits1[0].clone(false, deferred.promise, undefined, Math.max(bits1[0].threshold, bits2[0].threshold), 'share' + op_id);
 
       // big or of bitwise XORs
       var initial = bits1[0].isxor_bit(bits2[0], op_id + ':sxor_bit:initial');
@@ -5609,7 +5615,7 @@
 
       // initialize result
       var deferred = new Deferred();
-      var result = jiff.secret_share(jiff, false, deferred.promise, undefined, bits1[0].holders, Math.max(bits1[0].threshold, bits2[0].threshold), bits1[0].Zp, 'share:' + op_id);
+      var result = bits1[0].clone(false, deferred.promise, undefined, Math.max(bits1[0].threshold, bits2[0].threshold), 'share' + op_id);
 
       // Subtract bits2 from bits1, only keeping track of borrow
       var borrow = bits1[0].inot().ismult(bits2[0], op_id + ':smult:initial');
@@ -5796,7 +5802,7 @@
       if (constant.toString() === '1') {
         return {
           quotient: bits,
-          remainder: [jiff.secret_share(jiff, true, null, 0, bits[0].holders, 1, bits[0].Zp, 'share:' + op_id + ':zero_share')]
+          remainder: [bits[0].clone(true, null, 0, 1, 'share' + op_id + ':zero_share')]
         }
       }
 
@@ -5908,7 +5914,7 @@
 
         // add bit i to the head of remainder (least significant bit)
         // turn into a secret without communication, just for typing
-        var cbit_share = jiff.secret_share(jiff, true, null, constant_bits[i], bits[0].holders, 1, bits[0].Zp, 'share:' + op_id + ':' + iterationCounter);
+        var cbit_share = bits[0].clone(true, null, constant_bits[i], 1, 'share:' + op_id + ':' + iterationCounter);
         _remainder.unshift(cbit_share);
 
         // Get the next bit of the quotient