Update js test files to work with Web3 v1.0.

 - Use BigNumber.js and `.toString()` instead of `.valueOf()` because of issues with BN.js: web3/web3.js#2171
 - Use async / await with Web3 because all Web3 v1.0 calls are asynchronous

Author: Muhammad-Altabba

Diff for: package-lock.json

@@ -29,6 +29,7 @@
   "license": "LGPL-3.0",
   "dependencies": {
     "@gnosis.pm/util-contracts": "^3.0.0-alpha",
+    "bignumber.js": "^8.1.1",
     "canonical-weth": "^1.4.0",
     "openzeppelin-solidity": "^2.2.0"
   },
@@ -37,7 +38,7 @@
     "@gnosis.pm/truffle-nice-tools": "^1.1.3",
     "babel-eslint": "^10.0.1",
     "cross-env": "^5.2.0",
-    "decimal.js": "^10.0.0",
+    "decimal.js": "^10.1.1",
     "eslint": "^5.7.0",
     "eslint-plugin-babel": "^5.2.1",
     "fs-extra": "^7.0.0",

Diff for: package.json

@@ -0,0 +1,53 @@
+//This is a modified copy of: https://github.com/DigixGlobal/tempo/blob/master/lib/index.js
+// It is not compatible with Web3 v1.0 (https://github.com/DigixGlobal/tempo/issues/5)
+// A pull request has been created https://github.com/DigixGlobal/tempo/pull/4
+// In the mean time, a local modified copy is used.
+
+'use strict';
+
+module.exports = function (web3) {
+  function sendRpc(method, params) {
+    return new Promise(function (resolve) {
+      web3.currentProvider.send({
+        jsonrpc: '2.0',
+        method: method,
+        params: params || [],
+        id: new Date().getTime()
+      }, function (err, res) {
+        resolve(res);
+      });
+    });
+  }
+  function waitUntilBlock(seconds, targetBlock) {
+    return new Promise(function (resolve) {
+      var asyncIterator = function asyncIterator() {
+        return web3.eth.getBlock('latest', function (e, _ref) {
+          var number = _ref.number;
+
+          if (number >= targetBlock - 1) {
+            return sendRpc('evm_increaseTime', [seconds]).then(function () {
+              return sendRpc('evm_mine');
+            }).then(resolve);
+          }
+          return sendRpc('evm_mine').then(asyncIterator);
+        });
+      };
+      asyncIterator();
+    });
+  }
+  function wait() {
+    var seconds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 20;
+    var blocks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+
+    return new Promise(function (resolve) {
+      return web3.eth.getBlock('latest', function (e, _ref2) {
+        var number = _ref2.number;
+
+        resolve(blocks + number);
+      });
+    }).then(function (targetBlock) {
+      return waitUntilBlock(seconds, targetBlock);
+    });
+  }
+  return { wait: wait, waitUntilBlock: waitUntilBlock };
+};

Diff for: test/javascript/digix_tempo.js

@@ -22,12 +22,12 @@ contract('Event', function (accounts) {
         etherToken = await WETH9.deployed()
 
         // create event
-        ipfsHash = 'QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG'
-        oracle = utils.getParamFromTxEvent(
+        ipfsHash = web3.utils.utf8ToHex('QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG');
+        oracle = await utils.getParamFromTxEvent(
             await centralizedOracleFactory.createCentralizedOracle(ipfsHash),
             'centralizedOracle', CentralizedOracle
         )
-        event = utils.getParamFromTxEvent(
+        event = await utils.getParamFromTxEvent(
             await eventFactory.createCategoricalEvent(etherToken.address, oracle.address, 2),
             'categoricalEvent', CategoricalEvent
         )
@@ -36,18 +36,19 @@ contract('Event', function (accounts) {
     it('should buy and sell all outcomes', async () => {
         // Buy all outcomes
         const buyer = 0
-        const collateralTokenCount = 1e19
+        const collateralTokenCount = 1e19.toString() // https://github.com/ethereum/web3.js/issues/2077
+        const collateralTokenCountOver10 = 1e18.toString()
         await etherToken.deposit({ value: collateralTokenCount, from: accounts[buyer] })
-        assert.equal(await etherToken.balanceOf.call(accounts[buyer]), collateralTokenCount)
+        assert.equal(await etherToken.balanceOf.call(accounts[buyer]), collateralTokenCount) 
 
         await etherToken.approve(event.address, collateralTokenCount, { from: accounts[buyer] })
         for(let i = 0; i < 10; i++)
-            await event.buyAllOutcomes(collateralTokenCount / 10, { from: accounts[buyer] })
+            await event.buyAllOutcomes(collateralTokenCountOver10, { from: accounts[buyer] })
         assert.equal(await etherToken.balanceOf.call(event.address), collateralTokenCount)
         assert.equal(await etherToken.balanceOf.call(accounts[buyer]), 0)
 
-        const outcomeToken1 = OutcomeToken.at(await event.outcomeTokens.call(0))
-        const outcomeToken2 = OutcomeToken.at(await event.outcomeTokens.call(1))
+        const outcomeToken1 = await OutcomeToken.at(await event.outcomeTokens.call(0))
+        const outcomeToken2 = await OutcomeToken.at(await event.outcomeTokens.call(1))
         assert.equal(await outcomeToken1.balanceOf.call(accounts[buyer]), collateralTokenCount)
         assert.equal(await outcomeToken2.balanceOf.call(accounts[buyer]), collateralTokenCount)
 
@@ -62,18 +63,19 @@ contract('Event', function (accounts) {
     it('should buy and verify outcomes', async () => {
         // Buy all outcomes
         const buyer = 1
-        const collateralTokenCount = 1e18
+        const collateralTokenCount = 1e19.toString()
+        const collateralTokenCountDividedBy10 = 1e18.toString()
         await etherToken.deposit({ value: collateralTokenCount, from: accounts[buyer] })
         assert.equal(await etherToken.balanceOf.call(accounts[buyer]), collateralTokenCount)
 
         await etherToken.approve(event.address, collateralTokenCount, { from: accounts[buyer] })
         for(let i = 0; i < 10; i++)
-            await event.buyAllOutcomes(collateralTokenCount / 10, { from: accounts[buyer] })
+            await event.buyAllOutcomes(collateralTokenCountDividedBy10, { from: accounts[buyer] })
         assert.equal(await etherToken.balanceOf.call(event.address), collateralTokenCount)
         assert.equal(await etherToken.balanceOf.call(accounts[buyer]), 0)
 
-        const outcomeToken1 = OutcomeToken.at(await event.outcomeTokens.call(0))
-        const outcomeToken2 = OutcomeToken.at(await event.outcomeTokens.call(1))
+        const outcomeToken1 = await OutcomeToken.at(await event.outcomeTokens.call(0))
+        const outcomeToken2 = await OutcomeToken.at(await event.outcomeTokens.call(1))
         assert.equal(await outcomeToken1.balanceOf.call(accounts[buyer]), collateralTokenCount)
         assert.equal(await outcomeToken2.balanceOf.call(accounts[buyer]), collateralTokenCount)
 
@@ -83,7 +85,7 @@ contract('Event', function (accounts) {
         //using parseInt and .valueOf because of strictEqual comparison in arrays.deepEqual()
         const outcomeTokenDistribution = await event.getOutcomeTokenDistribution.call(accounts[buyer])
         assert.deepEqual(
-            [parseInt(outcomeTokenDistribution[0].valueOf(), 10), parseInt(outcomeTokenDistribution[1].valueOf(), 10)],
+            [parseInt(outcomeTokenDistribution[0].valueOf(), 10).toString(), parseInt(outcomeTokenDistribution[1].valueOf(), 10).toString()],
             [collateralTokenCount, collateralTokenCount])
     })
 
@@ -99,8 +101,8 @@ contract('Event', function (accounts) {
         assert.equal(await etherToken.balanceOf.call(event.address), collateralTokenCount)
         assert.equal(await etherToken.balanceOf.call(accounts[buyer]), 0)
 
-        const outcomeToken1 = OutcomeToken.at(await event.outcomeTokens.call(0))
-        const outcomeToken2 = OutcomeToken.at(await event.outcomeTokens.call(1))
+        const outcomeToken1 = await OutcomeToken.at(await event.outcomeTokens.call(0))
+        const outcomeToken2 = await OutcomeToken.at(await event.outcomeTokens.call(1))
         assert.equal(await outcomeToken1.balanceOf.call(accounts[buyer]), collateralTokenCount)
         assert.equal(await outcomeToken2.balanceOf.call(accounts[buyer]), collateralTokenCount)
 
@@ -115,7 +117,7 @@ contract('Event', function (accounts) {
         assert.equal(await event.isOutcomeSet.call(),true)
 
         //Redeem winnings for buyer account
-        const buyerWinnings = utils.getParamFromTxEvent(
+        const buyerWinnings = await utils.getParamFromTxEvent(
             await event.redeemWinnings({ from: accounts[buyer] }), 'winnings')
         assert.equal(buyerWinnings.valueOf(), collateralTokenCount)
         assert.equal(await outcomeToken1.balanceOf.call(accounts[buyer]), collateralTokenCount)
@@ -124,7 +126,7 @@ contract('Event', function (accounts) {
     })
 
     it('should buy, set, and redeem outcomes for scalar event', async () => {
-        const scalarEvent = utils.getParamFromTxEvent(
+        const scalarEvent = await utils.getParamFromTxEvent(
             await eventFactory.createScalarEvent(etherToken.address, oracle.address, -100, 100),
             'scalarEvent', ScalarEvent
         )
@@ -139,8 +141,8 @@ contract('Event', function (accounts) {
         assert.equal(await etherToken.balanceOf.call(scalarEvent.address), collateralTokenCount)
         assert.equal(await etherToken.balanceOf.call(accounts[buyer]), 0)
 
-        const outcomeToken1 = OutcomeToken.at(await scalarEvent.outcomeTokens(0))
-        const outcomeToken2 = OutcomeToken.at(await scalarEvent.outcomeTokens(1))
+        const outcomeToken1 = await OutcomeToken.at(await scalarEvent.outcomeTokens(0))
+        const outcomeToken2 = await OutcomeToken.at(await scalarEvent.outcomeTokens(1))
         assert.equal(await outcomeToken1.balanceOf.call(accounts[buyer]), collateralTokenCount)
         assert.equal(await outcomeToken2.balanceOf.call(accounts[buyer]), collateralTokenCount)
 
@@ -155,7 +157,7 @@ contract('Event', function (accounts) {
         assert.equal(await scalarEvent.isOutcomeSet.call(), true)
 
         //Redeem winnings for buyer account
-        const buyerWinnings = utils.getParamFromTxEvent(
+        const buyerWinnings = await utils.getParamFromTxEvent(
             await scalarEvent.redeemWinnings({ from: accounts[buyer] }), 'winnings')
         assert.equal(buyerWinnings.valueOf(), collateralTokenCount)
         assert.equal(await outcomeToken1.balanceOf.call(accounts[buyer]), 0)